Windows Development in C++, COM API Clients

#include "stdafx.h"
#include "hwinimaging.h"
#include "hwinhandle.h"

namespace harlinn
{
    namespace windows
    {
        namespace imaging
        {
            // -----------------------------------------------------------------
            // Palette
            // -----------------------------------------------------------------
            HWIN_EXPORT Palette& Palette::InitializePredefined( BitmapPaletteType ePaletteType, bool addTransparentColor)
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->InitializePredefined( WICBitmapPaletteType(ePaletteType), addTransparentColor);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT Palette& Palette::InitializeCustom( Color *pColors, UINT cCount)
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->InitializeCustom( pColors, cCount);
                CheckHRESULT(hr);
                return *this;
            }

            HWIN_EXPORT Palette& Palette::InitializeCustom( const std::vector< Color >& theColors)
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->InitializeCustom( (WICColor*)theColors.data(), UINT(theColors.size()));
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT Palette& Palette::InitializeCustom( std::shared_ptr<const std::vector< Color >>& theColors)
            {
                CheckPointerNotNull(theColors);
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->InitializeCustom( (WICColor*)theColors->data(), UINT(theColors->size()));
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT Palette& Palette::InitializeFromBitmap( const BitmapSource& theSurface, UINT cCount, bool addTransparentColor)
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->InitializeFromBitmap( theSurface, cCount, addTransparentColor);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT Palette& Palette::InitializeFromPalette(const Palette& thePalette)
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->InitializeFromPalette(thePalette);
                CheckHRESULT(hr);
                return *this;
            }
        
            HWIN_EXPORT BitmapPaletteType Palette::Type( ) const
            {
                InterfaceType* pInterface = GetInterface();
                BitmapPaletteType result;
                auto hr = pInterface->GetType((WICBitmapPaletteType*)&result);
                CheckHRESULT(hr);
                return result;
            }
            HWIN_EXPORT UINT Palette::GetColorCount( ) const
            {
                InterfaceType* pInterface = GetInterface();
                UINT result;
                auto hr = pInterface->GetColorCount(&result);
                CheckHRESULT(hr);
                return result;
            }
            HWIN_EXPORT std::shared_ptr<std::vector< Color > > Palette::Colors( ) const
            {
                InterfaceType* pInterface = GetInterface();
                auto count = GetColorCount();
                auto result = std::make_shared<std::vector< Color > >(size_t(count));
                auto hr = pInterface->GetColors(count,result->data(),&count);
                CheckHRESULT(hr);
                return result;
            }
            HWIN_EXPORT bool Palette::IsBlackWhite( ) const
            {
                InterfaceType* pInterface = GetInterface();
                BOOL result;
                auto hr = pInterface->IsBlackWhite(&result);
                CheckHRESULT(hr);
                return result != FALSE;
            }
            HWIN_EXPORT bool Palette::IsGrayscale( ) const
            {
                InterfaceType* pInterface = GetInterface();
                BOOL result;
                auto hr = pInterface->IsGrayscale(&result);
                CheckHRESULT(hr);
                return result != FALSE;
            }
            HWIN_EXPORT bool Palette::HasAlpha( ) const
            {
                InterfaceType* pInterface = GetInterface();
                BOOL result;
                auto hr = pInterface->HasAlpha(&result);
                CheckHRESULT(hr);
                return result != FALSE;
            }

            // -----------------------------------------------------------------
            // BitmapSource
            // -----------------------------------------------------------------
            HWIN_EXPORT const BitmapSource& BitmapSource::GetSize(UINT *puiWidth,UINT *puiHeight) const
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->GetSize(puiWidth,puiHeight);
                CheckHRESULT(hr);
                return *this;
            }

            HWIN_EXPORT Size BitmapSource::GetSize( ) const
            {
                UINT width = 0;
                UINT height = 0;
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->GetSize(&width,&height);
                CheckHRESULT(hr);
                return Size(width,height);
            }
            HWIN_EXPORT const BitmapSource& BitmapSource::GetPixelFormat( WICPixelFormatGUID *pPixelFormat) const
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->GetPixelFormat(pPixelFormat);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT WICPixelFormatGUID BitmapSource::GetPixelFormat( ) const
            {
                WICPixelFormatGUID result = {0,};
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->GetPixelFormat(&result);
                CheckHRESULT(hr);
                return result;
            }
            HWIN_EXPORT const BitmapSource& BitmapSource::GetResolution( double *pDpiX, double *pDpiY) const
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->GetResolution(pDpiX, pDpiY);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT Resolution BitmapSource::GetResolution( ) const
            {
                double dpiX, dpiY;
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->GetResolution(&dpiX, &dpiY);
                CheckHRESULT(hr);
                return Resolution(dpiX, dpiY);
            }

            HWIN_EXPORT const BitmapSource& BitmapSource::CopyPalette(Palette& theTargetPalette) const
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->CopyPalette(theTargetPalette);
                CheckHRESULT(hr);
                return *this;
            }

            HWIN_EXPORT Palette BitmapSource::CopyPalette( ) const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                
                Palette thePalette = factory->CreatePalette();
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->CopyPalette(thePalette);
                CheckHRESULT(hr);
                return thePalette;
            }
            HWIN_EXPORT const BitmapSource& BitmapSource::CopyPixels( Rectangle& rectangle, UINT bytePerStride, UINT bufferSize, BYTE *pbBuffer) const
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->CopyPixels( rectangle, bytePerStride, bufferSize, pbBuffer);
                CheckHRESULT(hr);
                return *this;
            }

            HWIN_EXPORT const BitmapSource& BitmapSource::CopyPixels( UINT bytePerStride, UINT bufferSize, BYTE *pbBuffer) const
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->CopyPixels( nullptr, bytePerStride, bufferSize, pbBuffer);
                CheckHRESULT(hr);
                return *this;
            }

            HWIN_EXPORT FormatConverter BitmapSource::Convert(REFGUID dstFormat, BitmapDitherType dither, const Palette& thePalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                FormatConverter result = factory->CreateFormatConverter();
                result.Initialize(*this,dstFormat, dither, thePalette, alphaThresholdPercent, paletteTranslate);
                return result;
            }

            HWIN_EXPORT FormatConverter BitmapSource::Convert(REFGUID dstFormat) const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                FormatConverter result = factory->CreateFormatConverter();
                result.Initialize(*this,dstFormat,0.0,BitmapPaletteType::Custom);
                return result;
            }
            HWIN_EXPORT FormatConverter BitmapSource::Convert() const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                FormatConverter result = factory->CreateFormatConverter();
                result.Initialize(*this,GUID_WICPixelFormat32bppBGR,0.0,BitmapPaletteType::Custom);
                return result;
            }
            HWIN_EXPORT BitmapScaler BitmapSource::Scale(UINT uiWidth, UINT uiHeight, BitmapInterpolationMode mode) const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                BitmapScaler result = factory->CreateBitmapScaler();
                result.Initialize(*this,uiWidth, uiHeight, mode);
                return result;
            }
            HWIN_EXPORT BitmapScaler BitmapSource::Scale(const Size& size, BitmapInterpolationMode mode) const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                BitmapScaler result = factory->CreateBitmapScaler();
                result.Initialize(*this,size.Width(), size.Height(), mode);
                return result;
            }
            HWIN_EXPORT BitmapClipper BitmapSource::Clip(const Rectangle& reactangle) const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                BitmapClipper result = factory->CreateBitmapClipper();
                result.Initialize(*this,reactangle);
                return result;
            }
            HWIN_EXPORT BitmapFlipRotator BitmapSource::Rotate(BitmapTransformOptions options) const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                BitmapFlipRotator result = factory->CreateBitmapFlipRotator();
                result.Initialize(*this,options);
                return result;
            }


            HWIN_EXPORT Bitmap BitmapSource::ToBitmap() const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                auto result = factory->CreateBitmapFromSource(*this,BitmapCreateCacheOption::CacheOnDemand);
                return result;
            }


            HWIN_EXPORT std::shared_ptr<BitmapHandle> BitmapSource::AsBitmapHandle() const
            {
                auto pixelFormat = this->GetPixelFormat();
                if(IsEqualGUID(GUID_WICPixelFormat32bppBGR,pixelFormat) == FALSE)
                {
                    auto converter = Convert();
                    auto result = converter.AsBitmapHandle();
                    return result;
                }
                else
                {
                    UINT width = 0;
                    UINT height = 0;
                    auto hr = GetSize(&width, &height);
                    CheckHRESULT(hr);

                    BITMAPINFO bminfo;
                    memset(&bminfo, 0,sizeof(bminfo));
                    bminfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
                    bminfo.bmiHeader.biWidth = width;
                    bminfo.bmiHeader.biHeight = -(LONG)height; //top-down DIB with origin in the upper-left corner
                    bminfo.bmiHeader.biPlanes = 1;
                    bminfo.bmiHeader.biBitCount = 32;
                    bminfo.bmiHeader.biCompression  = BI_RGB;

                    HDC hdcScreen = GetDC(NULL);
                    if(!hdcScreen)
                    {
                        ThrowLastOSError();
                    }

                    BYTE *imageBits = NULL;

                    HBITMAP hBitmap = CreateDIBSection(hdcScreen, &bminfo, DIB_RGB_COLORS,(void**)&imageBits, NULL, 0);
                    ReleaseDC(NULL, hdcScreen);
                    if(!hBitmap)
                    {
                        ThrowLastOSError();
                    }

                    UINT strideSize = width * 4;
                    UINT imageByteCount = strideSize*height;
                    hr = CopyPixels(strideSize,imageByteCount, imageBits);
            
                    if (FAILED(hr))
                    {
                        DeleteObject(hBitmap);
                        CheckHRESULT(hr);
                    }

                    auto result = std::make_shared<BitmapHandle>(hBitmap,true);
                    return result;
                }

            }
            


            // -----------------------------------------------------------------
            // FormatConverter
            // -----------------------------------------------------------------
            HWIN_EXPORT FormatConverter& FormatConverter::Initialize(const BitmapSource& theSource, REFGUID dstFormat, BitmapDitherType dither, const Palette& thePalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate)
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->Initialize(theSource, dstFormat, WICBitmapDitherType(dither), thePalette, alphaThresholdPercent, WICBitmapPaletteType(paletteTranslate));
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT FormatConverter& FormatConverter::Initialize(const BitmapSource& theSource, REFGUID dstFormat, double alphaThresholdPercent, BitmapPaletteType paletteTranslate)
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->Initialize(theSource, dstFormat, WICBitmapDitherTypeNone, nullptr, alphaThresholdPercent, WICBitmapPaletteType(paletteTranslate));
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT bool FormatConverter::CanConvert( REFGUID  srcPixelFormat,REFGUID  dstPixelFormat) const
            {
                InterfaceType* pInterface = GetInterface();
                BOOL result = FALSE;
                auto hr = pInterface->CanConvert( srcPixelFormat,dstPixelFormat,&result);
                CheckHRESULT(hr);
                return result != FALSE;
            }

            // -----------------------------------------------------------------
            // BitmapScaler
            // -----------------------------------------------------------------
            HWIN_EXPORT BitmapScaler& BitmapScaler::Initialize( const BitmapSource& theSource, UINT uiWidth, UINT uiHeight, BitmapInterpolationMode mode)
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->Initialize( theSource, uiWidth, uiHeight, WICBitmapInterpolationMode(mode));
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT BitmapScaler& BitmapScaler::Initialize( const BitmapSource& theSource, const Size& theSize, BitmapInterpolationMode mode)
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->Initialize( theSource, theSize.Width(), theSize.Height(), WICBitmapInterpolationMode(mode));
                CheckHRESULT(hr);
                return *this;
            }

            // -----------------------------------------------------------------
            // BitmapClipper
            // -----------------------------------------------------------------
            HWIN_EXPORT BitmapClipper& BitmapClipper::Initialize( const BitmapSource& theSource, const Rectangle& reactangle)
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->Initialize( theSource, reactangle);
                CheckHRESULT(hr);
                return *this;
            }

            // -----------------------------------------------------------------
            // BitmapFlipRotator
            // -----------------------------------------------------------------
            HWIN_EXPORT BitmapFlipRotator& BitmapFlipRotator::Initialize( const BitmapSource& theSource, BitmapTransformOptions options )
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->Initialize( theSource, WICBitmapTransformOptions(options));
                CheckHRESULT(hr);
                return *this;
            }

            // -----------------------------------------------------------------
            // BitmapLock
            // -----------------------------------------------------------------
            HWIN_EXPORT const BitmapLock& BitmapLock::GetSize( UINT *puiWidth, UINT *puiHeight) const
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->GetSize( puiWidth, puiHeight);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT Size BitmapLock::GetSize( ) const
            {
                UINT width = 0;
                UINT height = 0;
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->GetSize( &width, &height);
                CheckHRESULT(hr);
                return Size(width,height);
            }
        
            HWIN_EXPORT const BitmapLock& BitmapLock::GetStride( UINT *pcbStride) const
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->GetStride( pcbStride);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT UINT BitmapLock::GetStride( ) const
            {
                UINT stride;
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->GetStride(&stride);
                CheckHRESULT(hr);
                return stride;
            }
            HWIN_EXPORT const BitmapLock& BitmapLock::GetDataPointer( UINT *pcbBufferSize, BYTE **ppbData) const
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->GetDataPointer( pcbBufferSize, ppbData);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT const BitmapLock& BitmapLock::GetPixelFormat( GUID *pPixelFormat) const
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->GetPixelFormat( pPixelFormat);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT GUID BitmapLock::GetPixelFormat( ) const
            {
                GUID result = {0,};
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->GetPixelFormat( &result);
                CheckHRESULT(hr);
                return result;
            }

            // -----------------------------------------------------------------
            // Bitmap
            // -----------------------------------------------------------------
            HWIN_EXPORT BitmapLock Bitmap::Lock( const Rectangle& lockRectangle, DWORD flags)
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                IWICBitmapLock *result = nullptr;
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->Lock( lockRectangle,flags,& result);
                CheckHRESULT(hr);
                return BitmapLock(factory,result);
            }
            HWIN_EXPORT Bitmap& Bitmap::SetPalette( const Palette& thePalette)
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->SetPalette(thePalette);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT Bitmap& Bitmap::SetResolution( double dpiX, double dpiY)
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->SetResolution( dpiX, dpiY);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT Bitmap& Bitmap::SetResolution( const Resolution& resolution)
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->SetResolution( resolution.X(), resolution.Y());
                CheckHRESULT(hr);
                return *this;
            }

            // -----------------------------------------------------------------
            // ColorContext
            // -----------------------------------------------------------------
            HWIN_EXPORT ColorContext& ColorContext::InitializeFromFilename( LPCWSTR theFilename )
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->InitializeFromFilename( theFilename );
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT ColorContext& ColorContext::InitializeFromFilename( const String& theFilename )
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->InitializeFromFilename( theFilename.c_str() );
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT ColorContext& ColorContext::InitializeFromMemory( const BYTE *theBuffer, UINT theBufferSize)
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->InitializeFromMemory( theBuffer, theBufferSize );
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT ColorContext& ColorContext::InitializeFromExifColorSpace( UINT value)
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->InitializeFromExifColorSpace(value);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT ColorContextType ColorContext::GetType( ) const
            {
                ColorContextType result = ColorContextType::Uninitialized;
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->GetType((WICColorContextType*)&result);
                CheckHRESULT(hr);
                return result;
            }
            HWIN_EXPORT const ColorContext& ColorContext::GetProfileBytes( UINT bufferSize, BYTE *pbBuffer, UINT *actualNumberOfBytesCopied) const
            {
                ColorContextType result = ColorContextType::Uninitialized;
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->GetProfileBytes( bufferSize, pbBuffer, actualNumberOfBytesCopied);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT UINT ColorContext::GetExifColorSpace( ) const
            {
                UINT result = 0;
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->GetExifColorSpace(&result);
                CheckHRESULT(hr);
                return result;
            }

            // -----------------------------------------------------------------
            // ColorTransform
            // -----------------------------------------------------------------
            HWIN_EXPORT ColorTransform& ColorTransform::Initialize( const BitmapSource& theBitmapSource, const ColorContext& theContextSource, const ColorContext& theContextDest, REFGUID pixelFmtDest)
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->Initialize( theBitmapSource, theContextSource, theContextDest, pixelFmtDest);
                CheckHRESULT(hr);
                return *this;
            }

            // -----------------------------------------------------------------
            // Stream
            // -----------------------------------------------------------------
            HWIN_EXPORT Stream& Stream::InitializeFromIStream(IStream *theStream)
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->InitializeFromIStream(theStream);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT Stream& Stream::InitializeFromFilename( LPCWSTR theFileName, DWORD theDesiredAccess)
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->InitializeFromFilename( theFileName, theDesiredAccess);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT Stream& Stream::InitializeFromMemory( BYTE* theBuffer, DWORD theBufferSize)
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->InitializeFromMemory( theBuffer, theBufferSize);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT Stream& Stream::InitializeFromIStreamRegion( IStream* theStream, unsigned long long theOffset,unsigned long long theMaxSize)
            {
                ULARGE_INTEGER offset;
                ULARGE_INTEGER maxSize;
                offset.QuadPart = theOffset;
                maxSize.QuadPart = theMaxSize;
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->InitializeFromIStreamRegion( theStream, offset,maxSize);
                CheckHRESULT(hr);
                return *this;
            }

            // -----------------------------------------------------------------
            // EnumMetadataItem
            // -----------------------------------------------------------------
            HWIN_EXPORT bool EnumMetadataItem::Next( ULONG celt,
                    PROPVARIANT *rgeltSchema,PROPVARIANT *rgeltId,PROPVARIANT *rgeltValue,
                    ULONG *pceltFetched)
            {
                InterfaceType* pInterface = GetInterface();
                ULONG numberOfElementsFetched = 0;
                auto hr = pInterface->Next(celt, rgeltSchema,rgeltId,rgeltValue, &numberOfElementsFetched);
                if(SUCCEEDED(hr))
                {
                    if(pceltFetched)
                    {
                        *pceltFetched = numberOfElementsFetched;
                    }
                    return true;
                }
                return false;
            }
        
            HWIN_EXPORT EnumMetadataItem& EnumMetadataItem::Skip( ULONG celt )
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->Skip(celt);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT EnumMetadataItem& EnumMetadataItem::Reset( )
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->Reset();
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT EnumMetadataItem EnumMetadataItem::Clone( ) const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                InterfaceType* pClone = 0;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->Clone(&pClone);
                CheckHRESULT(hr);
                EnumMetadataItem result(factory,pClone);
                return result;
            }

            // -----------------------------------------------------------------
            // MetadataQueryReader
            // -----------------------------------------------------------------
            HWIN_EXPORT const MetadataQueryReader& MetadataQueryReader::GetContainerFormat(GUID *pguidContainerFormat) const
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetContainerFormat(pguidContainerFormat);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT GUID MetadataQueryReader::GetContainerFormat( ) const
            {
                GUID result = {0,};
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetContainerFormat(&result);
                CheckHRESULT(hr);
                return result;
            }
            HWIN_EXPORT const MetadataQueryReader& MetadataQueryReader::GetLocation( UINT cchMaxLength,WCHAR *wzNamespace, UINT *pcchActualLength) const
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetLocation( cchMaxLength,wzNamespace, pcchActualLength);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT String MetadataQueryReader::GetLocation( ) const
            {
                UINT actualLength = 0;
                WCHAR buffer[512];
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetLocation( sizeof(buffer)/sizeof(WCHAR),buffer, &actualLength);
                CheckHRESULT(hr);
                return String(buffer,size_t(actualLength));
            }
            HWIN_EXPORT const MetadataQueryReader& MetadataQueryReader::GetMetadataByName( LPCWSTR wzName,PROPVARIANT *pvarValue) const
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetMetadataByName( wzName,pvarValue);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT const MetadataQueryReader& MetadataQueryReader::GetMetadataByName( const String& theName,PROPVARIANT *pvarValue) const
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetMetadataByName( theName.c_str(),pvarValue);
                CheckHRESULT(hr);
                return *this;
            }
        
            HWIN_EXPORT EnumString MetadataQueryReader::GetEnumerator( ) const
            {
                IEnumString* result;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetEnumerator( &result );
                CheckHRESULT(hr);
                return EnumString(result);
            }

            // -----------------------------------------------------------------
            // MetadataQueryWriter
            // -----------------------------------------------------------------
            HWIN_EXPORT MetadataQueryWriter& MetadataQueryWriter::SetMetadataByName( LPCWSTR wzName, const PROPVARIANT *pvarValue)
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->SetMetadataByName( wzName, pvarValue);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT MetadataQueryWriter& MetadataQueryWriter::RemoveMetadataByName(LPCWSTR wzName)
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->RemoveMetadataByName(wzName);
                CheckHRESULT(hr);
                return *this;
            }

            // -----------------------------------------------------------------
            // BitmapEncoder
            // -----------------------------------------------------------------
            HWIN_EXPORT BitmapEncoder& BitmapEncoder::Initialize(IStream* theStream, BitmapEncoderCacheOption cacheOption)
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->Initialize(theStream, WICBitmapEncoderCacheOption(cacheOption));
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT const BitmapEncoder& BitmapEncoder::GetContainerFormat(GUID *pguidContainerFormat) const
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetContainerFormat(pguidContainerFormat);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT GUID BitmapEncoder::GetContainerFormat( ) const
            {
                GUID result = {0,};
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetContainerFormat(&result);
                CheckHRESULT(hr);
                return result;
            }

            HWIN_EXPORT BitmapEncoderInfo BitmapEncoder::GetEncoderInfo( ) const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                IWICBitmapEncoderInfo* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetEncoderInfo(&result);
                CheckHRESULT(hr);
                return BitmapEncoderInfo(factory,result);
            }

            HWIN_EXPORT BitmapEncoder& BitmapEncoder::SetColorContexts( std::shared_ptr< std::vector<ColorContext> > colorContexts )
            {
                InterfaceType* pInterface = GetInterface( );
                std::vector<IWICColorContext*> contexts;
                contexts.reserve(colorContexts->size());
                for(auto it = colorContexts->begin(); it != colorContexts->end(); it++)
                {
                    contexts.push_back(*it);
                }
                auto hr = pInterface->SetColorContexts(UINT(contexts.size()),contexts.data());
                CheckHRESULT(hr);
                return *this;
            }

            HWIN_EXPORT BitmapEncoder& BitmapEncoder::SetPalette( const Palette& thePalette )
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->SetPalette( thePalette );
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT BitmapEncoder& BitmapEncoder::SetThumbnail( const BitmapSource& theThumbnail)
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->SetThumbnail( theThumbnail );
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT BitmapEncoder& BitmapEncoder::SetPreview( const BitmapSource& thePreview)
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->SetPreview( thePreview );
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT BitmapFrameEncode BitmapEncoder::CreateNewFrame( IPropertyBag2 **ppIEncoderOptions)
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                IWICBitmapFrameEncode* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateNewFrame(&result,ppIEncoderOptions);
                CheckHRESULT(hr);
                return BitmapFrameEncode(factory,result);
            }
            HWIN_EXPORT BitmapFrameEncode BitmapEncoder::CreateNewFrame( )
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                IWICBitmapFrameEncode* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateNewFrame(&result,nullptr);
                CheckHRESULT(hr);
                return BitmapFrameEncode(factory,result);
            }
            HWIN_EXPORT BitmapEncoder& BitmapEncoder::Commit( )
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->Commit( );
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT MetadataQueryWriter BitmapEncoder::GetMetadataQueryWriter() const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                IWICMetadataQueryWriter* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetMetadataQueryWriter(&result);
                CheckHRESULT(hr);
                return MetadataQueryWriter(factory,result);
            }

            // -----------------------------------------------------------------
            // BitmapFrameEncode
            // -----------------------------------------------------------------
            HWIN_EXPORT BitmapFrameEncode& BitmapFrameEncode::Initialize( )
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->Initialize( nullptr );
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT BitmapFrameEncode& BitmapFrameEncode::Initialize(IPropertyBag2 *pIEncoderOptions)
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->Initialize( pIEncoderOptions );
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT BitmapFrameEncode& BitmapFrameEncode::SetSize(UINT uiWidth,UINT uiHeight)
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->SetSize(uiWidth,uiHeight);
                CheckHRESULT(hr);
                return *this;
            }

            HWIN_EXPORT BitmapFrameEncode& BitmapFrameEncode::SetSize(const Size& size)
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->SetSize(size.Width(),size.Height());
                CheckHRESULT(hr);
                return *this;
            }

            HWIN_EXPORT BitmapFrameEncode& BitmapFrameEncode::SetResolution(double dpiX, double dpiY)
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->SetResolution(dpiX, dpiY);
                CheckHRESULT(hr);
                return *this;
            }

            HWIN_EXPORT BitmapFrameEncode& BitmapFrameEncode::SetResolution(const Resolution& resolution)
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->SetResolution(resolution.X(),resolution.Y());
                CheckHRESULT(hr);
                return *this;
            }

            HWIN_EXPORT BitmapFrameEncode& BitmapFrameEncode::SetPixelFormat( GUID *pPixelFormat)
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->SetPixelFormat( pPixelFormat);
                CheckHRESULT(hr);
                return *this;
            }

            HWIN_EXPORT BitmapFrameEncode& BitmapFrameEncode::SetPixelFormat( const GUID& thePixelFormat)
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->SetPixelFormat( (GUID*)&thePixelFormat);
                CheckHRESULT(hr);
                return *this;
            }

            HWIN_EXPORT BitmapFrameEncode& BitmapFrameEncode::SetColorContexts( std::shared_ptr< std::vector<ColorContext> > colorContexts )
            {
                InterfaceType* pInterface = GetInterface( );
                std::vector<IWICColorContext*> contexts;
                contexts.reserve(colorContexts->size());
                for(auto it = colorContexts->begin(); it != colorContexts->end(); it++)
                {
                    contexts.push_back(*it);
                }
                auto hr = pInterface->SetColorContexts(UINT(contexts.size()),contexts.data());
                CheckHRESULT(hr);
                return *this;
            }

            HWIN_EXPORT BitmapFrameEncode& BitmapFrameEncode::SetPalette( const Palette& thePalette )
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->SetPalette( thePalette );
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT BitmapFrameEncode& BitmapFrameEncode::SetThumbnail( const BitmapSource& theThumbnail)
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->SetThumbnail( theThumbnail );
                CheckHRESULT(hr);
                return *this;
            }
        
            HWIN_EXPORT BitmapFrameEncode& BitmapFrameEncode::WritePixels(UINT lineCount, UINT cbStride, UINT cbBufferSize, BYTE *pbPixels)
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->WritePixels(lineCount, cbStride, cbBufferSize, pbPixels);
                CheckHRESULT(hr);
                return *this;
            }

            HWIN_EXPORT BitmapFrameEncode& BitmapFrameEncode::WriteSource( const BitmapSource& theBitmapSource, const Rectangle& rectangle)
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->WriteSource( theBitmapSource, rectangle);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT BitmapFrameEncode& BitmapFrameEncode::WriteSource( const BitmapSource& theBitmapSource)
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->WriteSource( theBitmapSource, nullptr);
                CheckHRESULT(hr);
                return *this;
            }

            HWIN_EXPORT BitmapFrameEncode& BitmapFrameEncode::Commit( )
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->Commit( );
                CheckHRESULT(hr);
                return *this;
            }
        
            HWIN_EXPORT MetadataQueryWriter BitmapFrameEncode::GetMetadataQueryWriter( ) const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                IWICMetadataQueryWriter* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetMetadataQueryWriter(&result);
                CheckHRESULT(hr);
                return MetadataQueryWriter(factory,result);
            }

            // -----------------------------------------------------------------
            // ImageEncoder
            // -----------------------------------------------------------------
            HWIN_EXPORT ImageEncoder& ImageEncoder::WriteFrame( ID2D1Image *pImage, const BitmapFrameEncode& theFrameEncoder, const ImageParameters& theImageParameters)
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->WriteFrame( pImage, theFrameEncoder, (WICImageParameters*) &theImageParameters);
                CheckHRESULT(hr);
                return *this;
            }

            HWIN_EXPORT ImageEncoder& ImageEncoder::WriteFrameThumbnail( ID2D1Image *pImage, const BitmapFrameEncode& theFrameEncoder, const ImageParameters& theImageParameters)
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->WriteFrameThumbnail( pImage, theFrameEncoder, (WICImageParameters*) &theImageParameters);
                CheckHRESULT(hr);
                return *this;
            }

            HWIN_EXPORT ImageEncoder& ImageEncoder::WriteThumbnail( ID2D1Image *pImage, const BitmapEncoder& theEncoder, const ImageParameters& theImageParameters)
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->WriteThumbnail( pImage, theEncoder, (WICImageParameters*) &theImageParameters);
                CheckHRESULT(hr);
                return *this;
            }

            // -----------------------------------------------------------------
            // BitmapDecoder
            // -----------------------------------------------------------------
            HWIN_EXPORT DWORD BitmapDecoder::QueryCapability( IStream * theStream) const
            {
                DWORD result = 0;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->QueryCapability( theStream,&result);
                CheckHRESULT(hr);
                return result;
            }
            HWIN_EXPORT BitmapDecoder& BitmapDecoder::Initialize( IStream* theStream, DecodeOptions cacheOptions)
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->Initialize( theStream, WICDecodeOptions(cacheOptions));
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT const BitmapDecoder& BitmapDecoder::GetContainerFormat(GUID *pguidContainerFormat) const
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetContainerFormat(pguidContainerFormat);
                CheckHRESULT(hr);
                return *this;
            }


            HWIN_EXPORT GUID BitmapDecoder::GetContainerFormat( ) const
            {
                GUID result = {0,};
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetContainerFormat(&result);
                CheckHRESULT(hr);
                return result;
            }

            HWIN_EXPORT BitmapDecoderInfo BitmapDecoder::GetDecoderInfo( ) const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                IWICBitmapDecoderInfo* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetDecoderInfo(&result);
                CheckHRESULT(hr);
                return BitmapDecoderInfo(factory,result);
            }

            HWIN_EXPORT const BitmapDecoder& BitmapDecoder::CopyPalette(Palette& theTargetPalette) const
            {
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->CopyPalette(theTargetPalette);
                CheckHRESULT(hr);
                return *this;
            }

            HWIN_EXPORT Palette BitmapDecoder::CopyPalette( ) const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                
                Palette thePalette = factory->CreatePalette();
                InterfaceType* pInterface = GetInterface();
                auto hr = pInterface->CopyPalette(thePalette);
                CheckHRESULT(hr);
                return thePalette;
            }
        
            HWIN_EXPORT MetadataQueryReader BitmapDecoder::GetMetadataQueryReader( ) const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                IWICMetadataQueryReader* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetMetadataQueryReader(&result);
                CheckHRESULT(hr);
                return MetadataQueryReader(factory,result);
            }

            HWIN_EXPORT BitmapSource BitmapDecoder::GetPreview( ) const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                IWICBitmapSource* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetPreview(&result);
                CheckHRESULT(hr);
                return BitmapSource(factory,result);
            }

            HWIN_EXPORT std::shared_ptr< std::vector<ColorContext> >  BitmapDecoder::GetColorContexts( ) const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                auto result = std::make_shared< std::vector<ColorContext> >();

                IWICColorContext* colorContexts[128];
                UINT actual = 0;
                InterfaceType* pInterface = GetInterface( );

                auto hr = pInterface->GetColorContexts(128,colorContexts,&actual);
                CheckHRESULT(hr);
                
                for(UINT i = 0; i < actual; i++)
                {
                    result->push_back(ColorContext(factory,colorContexts[i]));
                }
                return result; 
            }

            HWIN_EXPORT BitmapSource BitmapDecoder::GetThumbnail( ) const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                IWICBitmapSource* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetThumbnail(&result);
                CheckHRESULT(hr);
                return BitmapSource(factory,result);
            }

            HWIN_EXPORT UINT BitmapDecoder::GetFrameCount( ) const
            {
                UINT result = 0;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetFrameCount(&result);
                CheckHRESULT(hr);
                return result;
            }

            HWIN_EXPORT BitmapFrameDecode BitmapDecoder::GetFrame(UINT index) const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                IWICBitmapFrameDecode* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetFrame(index,&result);
                CheckHRESULT(hr);
                return BitmapFrameDecode(factory,result);
            }

            // -----------------------------------------------------------------
            // BitmapSourceTransform
            // -----------------------------------------------------------------
            HWIN_EXPORT const BitmapSourceTransform& BitmapSourceTransform::CopyPixels( const Rectangle& rectangle, UINT uiWidth, UINT uiHeight, WICPixelFormatGUID *pguidDstFormat,BitmapTransformOptions dstTransform,UINT nStride,UINT cbBufferSize,BYTE *pbBuffer) const
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CopyPixels( rectangle, uiWidth, uiHeight, pguidDstFormat,WICBitmapTransformOptions(dstTransform),nStride,cbBufferSize,pbBuffer);
                CheckHRESULT(hr);
                return *this;
            }

            HWIN_EXPORT const BitmapSourceTransform& BitmapSourceTransform::GetClosestSize( UINT *puiWidth,UINT *puiHeight) const
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetClosestSize( puiWidth,puiHeight);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT const BitmapSourceTransform& BitmapSourceTransform::GetClosestPixelFormat( WICPixelFormatGUID *pguidDstFormat) const
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetClosestPixelFormat( pguidDstFormat);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT bool BitmapSourceTransform::DoesSupportTransform( BitmapTransformOptions dstTransform) const
            {
                InterfaceType* pInterface = GetInterface( );
                BOOL result = FALSE;
                auto hr = pInterface->DoesSupportTransform( WICBitmapTransformOptions( dstTransform ),&result);
                CheckHRESULT(hr);
                return result != FALSE;
            }

            // -----------------------------------------------------------------
            // BitmapFrameDecode
            // -----------------------------------------------------------------
            HWIN_EXPORT MetadataQueryReader BitmapFrameDecode::GetMetadataQueryReader( ) const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                IWICMetadataQueryReader* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetMetadataQueryReader(&result);
                CheckHRESULT(hr);
                return MetadataQueryReader(factory,result);
            }

            HWIN_EXPORT std::shared_ptr< std::vector<ColorContext> > BitmapFrameDecode::GetColorContexts( ) const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                auto result = std::make_shared< std::vector<ColorContext> >();

                IWICColorContext* colorContexts[128];
                UINT actual = 0;
                InterfaceType* pInterface = GetInterface( );

                auto hr = pInterface->GetColorContexts(128,colorContexts,&actual);
                CheckHRESULT(hr);
                
                for(UINT i = 0; i < actual; i++)
                {
                    result->push_back(ColorContext(factory,colorContexts[i]));
                }
                return result; 
            }

            HWIN_EXPORT BitmapSource BitmapFrameDecode::GetThumbnail( ) const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                IWICBitmapSource* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetThumbnail(&result);
                CheckHRESULT(hr);
                return BitmapSource(factory,result);
            }

            // -----------------------------------------------------------------
            // BitmapCodecProgressNotification
            // -----------------------------------------------------------------
            HWIN_EXPORT BitmapCodecProgressNotification& BitmapCodecProgressNotification::RegisterProgressNotification( PFNProgressNotification pfnProgressNotification, LPVOID pvData,DWORD dwProgressFlags)
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->RegisterProgressNotification( pfnProgressNotification, pvData,dwProgressFlags);
                CheckHRESULT(hr);
                return *this;
            }


            // -----------------------------------------------------------------
            // ComponentInfo
            // -----------------------------------------------------------------
            HWIN_EXPORT ComponentType ComponentInfo::GetComponentType( ) const
            {
                ComponentType result;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetComponentType( (WICComponentType*) &result );
                CheckHRESULT(hr);
                return result;
            }
            HWIN_EXPORT const ComponentInfo& ComponentInfo::GetCLSID( CLSID *pclsid) const
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetCLSID(pclsid);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT CLSID ComponentInfo::GetCLSID( ) const
            {
                CLSID result = {0,};
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetCLSID(&result);
                CheckHRESULT(hr);
                return result;
            }
        
            HWIN_EXPORT DWORD ComponentInfo::GetSigningStatus( ) const
            {
                DWORD result = 0;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetSigningStatus(&result);
                CheckHRESULT(hr);
                return result;
            }

            HWIN_EXPORT String ComponentInfo::GetAuthor( ) const
            {
                InterfaceType* pInterface = GetInterface( );
                WCHAR buffer[1024];
                UINT actual = 0;
                auto hr = pInterface->GetAuthor(1024,buffer,&actual);
                CheckHRESULT(hr);
                return String(buffer,size_t(actual));
            }

            HWIN_EXPORT const ComponentInfo& ComponentInfo::GetVendorGUID(GUID *pguidVendor) const
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetVendorGUID(pguidVendor);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT GUID ComponentInfo::GetVendorGUID( ) const
            {
                GUID result = {0,};
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetVendorGUID(&result);
                CheckHRESULT(hr);
                return result;
            }
        
            HWIN_EXPORT String ComponentInfo::GetVersion( ) const
            {
                InterfaceType* pInterface = GetInterface( );
                WCHAR buffer[1024];
                UINT actual = 0;
                auto hr = pInterface->GetVersion(1024,buffer,&actual);
                CheckHRESULT(hr);
                return String(buffer,size_t(actual));
            }
        
            HWIN_EXPORT String ComponentInfo::GetSpecVersion( ) const
            {
                InterfaceType* pInterface = GetInterface( );
                WCHAR buffer[1024];
                UINT actual = 0;
                auto hr = pInterface->GetSpecVersion(1024,buffer,&actual);
                CheckHRESULT(hr);
                return String(buffer,size_t(actual));
            }
        
            HWIN_EXPORT String ComponentInfo::GetFriendlyName( ) const
            {
                InterfaceType* pInterface = GetInterface( );
                WCHAR buffer[1024];
                UINT actual = 0;
                auto hr = pInterface->GetFriendlyName(1024,buffer,&actual);
                CheckHRESULT(hr);
                return String(buffer,size_t(actual));
            }

            // -----------------------------------------------------------------
            // FormatConverterInfo
            // -----------------------------------------------------------------
            HWIN_EXPORT std::shared_ptr< std::vector<WICPixelFormatGUID> > FormatConverterInfo::GetPixelFormats( ) const
            {
                auto result = std::make_shared< std::vector<WICPixelFormatGUID> >();
                InterfaceType* pInterface = GetInterface( );
                WICPixelFormatGUID buffer[64];
                UINT actual = 0;
                auto hr = pInterface->GetPixelFormats(64,buffer,&actual);
                CheckHRESULT(hr);

                for(UINT i = 0; i < actual; i++)
                {
                    result->push_back(buffer[i]);
                }

                return result;
            }
            HWIN_EXPORT FormatConverter FormatConverterInfo::CreateInstance( ) const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                IWICFormatConverter* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateInstance(&result);
                CheckHRESULT(hr);
                return FormatConverter(factory,result);
            }

            // -----------------------------------------------------------------
            // BitmapCodecInfo
            // -----------------------------------------------------------------
            HWIN_EXPORT const BitmapCodecInfo& BitmapCodecInfo::GetContainerFormat(GUID *pguidContainerFormat) const
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetContainerFormat(pguidContainerFormat);
                CheckHRESULT(hr);
                return *this;
            }
            HWIN_EXPORT GUID BitmapCodecInfo::GetContainerFormat( ) const
            {
                GUID result = {0,};
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetContainerFormat(&result);
                CheckHRESULT(hr);
                return result;
            }

            HWIN_EXPORT std::shared_ptr< std::vector<WICPixelFormatGUID> > BitmapCodecInfo::GetPixelFormats( ) const
            {
                auto result = std::make_shared< std::vector<WICPixelFormatGUID> >();
                InterfaceType* pInterface = GetInterface( );
                WICPixelFormatGUID buffer[64];
                UINT actual = 0;
                auto hr = pInterface->GetPixelFormats(64,buffer,&actual);
                CheckHRESULT(hr);

                for(UINT i = 0; i < actual; i++)
                {
                    result->push_back(buffer[i]);
                }

                return result;
            }

            HWIN_EXPORT String BitmapCodecInfo::GetColorManagementVersion( ) const
            {
                InterfaceType* pInterface = GetInterface( );
                WCHAR buffer[1024];
                UINT actual = 0;
                auto hr = pInterface->GetColorManagementVersion(1024,buffer,&actual);
                CheckHRESULT(hr);
                return String(buffer,size_t(actual));
            }
            HWIN_EXPORT String BitmapCodecInfo::GetDeviceManufacturer( ) const
            {
                InterfaceType* pInterface = GetInterface( );
                WCHAR buffer[1024];
                UINT actual = 0;
                auto hr = pInterface->GetDeviceManufacturer(1024,buffer,&actual);
                CheckHRESULT(hr);
                return String(buffer,size_t(actual));
            }
            HWIN_EXPORT String BitmapCodecInfo::GetDeviceModels( ) const
            {
                InterfaceType* pInterface = GetInterface( );
                WCHAR buffer[1024];
                UINT actual = 0;
                auto hr = pInterface->GetDeviceModels(1024,buffer,&actual);
                CheckHRESULT(hr);
                return String(buffer,size_t(actual));
            }
            HWIN_EXPORT String BitmapCodecInfo::GetMimeTypes( ) const
            {
                InterfaceType* pInterface = GetInterface( );
                WCHAR buffer[1024];
                UINT actual = 0;
                auto hr = pInterface->GetMimeTypes(1024,buffer,&actual);
                CheckHRESULT(hr);
                return String(buffer,size_t(actual));
            }
            HWIN_EXPORT String BitmapCodecInfo::GetFileExtensions( ) const
            {
                InterfaceType* pInterface = GetInterface( );
                WCHAR buffer[1024];
                UINT actual = 0;
                auto hr = pInterface->GetFileExtensions(1024,buffer,&actual);
                CheckHRESULT(hr);
                return String(buffer,size_t(actual));
            }

            HWIN_EXPORT bool BitmapCodecInfo::DoesSupportAnimation() const
            {
                InterfaceType* pInterface = GetInterface( );
                BOOL result = FALSE;
                auto hr = pInterface->DoesSupportAnimation(&result);
                CheckHRESULT(hr);
                return result != FALSE;
            }

            HWIN_EXPORT bool BitmapCodecInfo::DoesSupportChromakey( ) const
            {
                InterfaceType* pInterface = GetInterface( );
                BOOL result = FALSE;
                auto hr = pInterface->DoesSupportChromakey(&result);
                CheckHRESULT(hr);
                return result != FALSE;
            }
            HWIN_EXPORT bool BitmapCodecInfo::DoesSupportLossless( ) const
            {
                InterfaceType* pInterface = GetInterface( );
                BOOL result = FALSE;
                auto hr = pInterface->DoesSupportLossless(&result);
                CheckHRESULT(hr);
                return result != FALSE;
            }
            HWIN_EXPORT bool BitmapCodecInfo::DoesSupportMultiframe( ) const
            {
                InterfaceType* pInterface = GetInterface( );
                BOOL result = FALSE;
                auto hr = pInterface->DoesSupportMultiframe(&result);
                CheckHRESULT(hr);
                return result != FALSE;
            }
            HWIN_EXPORT bool BitmapCodecInfo::MatchesMimeType(LPCWSTR wzMimeType) const
            {
                InterfaceType* pInterface = GetInterface( );
                BOOL result = FALSE;
                auto hr = pInterface->MatchesMimeType(wzMimeType,&result);
                CheckHRESULT(hr);
                return result != FALSE;
            }
            HWIN_EXPORT bool BitmapCodecInfo::MatchesMimeType(const String& theMimeType) const
            {
                InterfaceType* pInterface = GetInterface( );
                BOOL result = FALSE;
                auto hr = pInterface->MatchesMimeType(theMimeType.c_str(),&result);
                CheckHRESULT(hr);
                return result != FALSE;
            }

            // -----------------------------------------------------------------
            // BitmapEncoderInfo
            // -----------------------------------------------------------------
            HWIN_EXPORT BitmapEncoder BitmapEncoderInfo::CreateInstance( )
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                IWICBitmapEncoder* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateInstance(&result);
                CheckHRESULT(hr);
                return BitmapEncoder(factory,result);
            }

            // -----------------------------------------------------------------
            // BitmapDecoderInfo
            // -----------------------------------------------------------------
            HWIN_EXPORT std::shared_ptr< std::vector<BitmapPattern> > BitmapDecoderInfo::GetPatterns( ) const
            {
                
                InterfaceType* pInterface = GetInterface( );
                
                UINT actual = 0;
                UINT actualBufferSize = 0;
                auto hr = pInterface->GetPatterns(0,nullptr,&actual,&actualBufferSize);
                CheckHRESULT(hr);
                auto result = std::make_shared< std::vector<BitmapPattern> >(actual);

                hr = pInterface->GetPatterns(actual,(WICBitmapPattern*)result->data(),&actual,&actualBufferSize);
                CheckHRESULT(hr);
                return result;
            }
        
            HWIN_EXPORT bool BitmapDecoderInfo::MatchesPattern( IStream *theStream) const
            {
                BOOL result = FALSE;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->MatchesPattern(theStream,&result);
                CheckHRESULT(hr);
                return result != FALSE;
            }
        
            HWIN_EXPORT BitmapDecoder BitmapDecoderInfo::CreateInstance( ) const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                IWICBitmapDecoder* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateInstance(&result);
                CheckHRESULT(hr);
                return BitmapDecoder(factory,result);
            }

            // -----------------------------------------------------------------
            // PixelFormatInfo
            // -----------------------------------------------------------------
            HWIN_EXPORT const PixelFormatInfo& PixelFormatInfo::GetFormatGUID(GUID *pFormat) const
            {
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetFormatGUID(pFormat);
                CheckHRESULT(hr);
                return *this;
            }
        
            HWIN_EXPORT ColorContext PixelFormatInfo::GetColorContext( ) const
            {
                ImagingFactory* factory = Factory();
                if(!factory)
                {
                    throw InvalidOperationException("ImagingFactory is not assigned");
                }
                IWICColorContext* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetColorContext(&result);
                CheckHRESULT(hr);
                return ColorContext(factory,result);
            }

            HWIN_EXPORT UINT PixelFormatInfo::GetBitsPerPixel( ) const
            {
                UINT result = 0;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetBitsPerPixel(&result);
                CheckHRESULT(hr);
                return *this;
            }

            HWIN_EXPORT UINT PixelFormatInfo::GetChannelCount( ) const
            {
                UINT result = 0;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetChannelCount(&result);
                CheckHRESULT(hr);
                return *this;
            }
        
            HWIN_EXPORT std::shared_ptr< std::vector<BYTE> > PixelFormatInfo::GetChannelMask( UINT uiChannelIndex ) const
            {
                UINT actual;
                BYTE buffer[512];
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->GetChannelMask(uiChannelIndex,512,buffer, &actual);
                CheckHRESULT(hr);
                auto result = std::make_shared< std::vector<BYTE> >(buffer,buffer+actual);
                return result;
            }

            // IWICPixelFormatInfo2
           // HWIN_EXPORT bool PixelFormatInfo::SupportsTransparency( ) const
        
          //  HWIN_EXPORT PixelFormatNumericRepresentation PixelFormatInfo::GetNumericRepresentation( ) const

            // -----------------------------------------------------------------
            // ImagingFactory
            // -----------------------------------------------------------------

            HWIN_EXPORT ImagingFactory ImagingFactory::Create()
            {
                IWICImagingFactory *pIWICFactory = nullptr;
                HRESULT hr = CoCreateInstance(CLSID_WICImagingFactory1,NULL,CLSCTX_INPROC_SERVER,IID_PPV_ARGS(&pIWICFactory));
                CheckHRESULT(hr);

                ImagingFactory result(pIWICFactory);
                return result;
            }

            HWIN_EXPORT BitmapDecoder ImagingFactory::CreateDecoderFromFilename( LPCWSTR theFilename,const GUID *pguidVendor, DWORD dwDesiredAccess, DecodeOptions metadataOptions) const
            {
                IWICBitmapDecoder* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateDecoderFromFilename( theFilename,pguidVendor, dwDesiredAccess, WICDecodeOptions(metadataOptions),&result);
                CheckHRESULT(hr);
                return BitmapDecoder(const_cast<ImagingFactory*>(this),result);
            }
            HWIN_EXPORT BitmapDecoder ImagingFactory::CreateDecoderFromFilename( LPCWSTR theFilename, DWORD dwDesiredAccess, DecodeOptions metadataOptions) const
            {
                IWICBitmapDecoder* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateDecoderFromFilename( theFilename,nullptr, dwDesiredAccess, WICDecodeOptions(metadataOptions),&result);
                CheckHRESULT(hr);
                return BitmapDecoder(const_cast<ImagingFactory*>(this),result);
            }
            HWIN_EXPORT BitmapDecoder ImagingFactory::CreateDecoderFromFilename( LPCWSTR theFilename ) const
            {
                IWICBitmapDecoder* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateDecoderFromFilename( theFilename,nullptr, GENERIC_READ, WICDecodeMetadataCacheOnDemand,&result);
                CheckHRESULT(hr);
                return BitmapDecoder(const_cast<ImagingFactory*>(this),result);
            }
            HWIN_EXPORT BitmapDecoder ImagingFactory::CreateDecoderFromFilename( const String& theFilename,const GUID *pguidVendor, DWORD dwDesiredAccess, DecodeOptions metadataOptions) const
            {
                IWICBitmapDecoder* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateDecoderFromFilename( theFilename.c_str(),pguidVendor, dwDesiredAccess, WICDecodeOptions(metadataOptions),&result);
                CheckHRESULT(hr);
                return BitmapDecoder(const_cast<ImagingFactory*>(this),result);
            }
            HWIN_EXPORT BitmapDecoder ImagingFactory::CreateDecoderFromFilename( const String& theFilename, DWORD dwDesiredAccess, DecodeOptions metadataOptions) const
            {
                IWICBitmapDecoder* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateDecoderFromFilename( theFilename.c_str(),nullptr, dwDesiredAccess, WICDecodeOptions(metadataOptions),&result);
                CheckHRESULT(hr);
                return BitmapDecoder(const_cast<ImagingFactory*>(this),result);
            }
            HWIN_EXPORT BitmapDecoder ImagingFactory::CreateDecoderFromFilename( const String& theFilename ) const
            {
                IWICBitmapDecoder* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateDecoderFromFilename( theFilename.c_str(),nullptr, GENERIC_READ, WICDecodeMetadataCacheOnDemand,&result);
                CheckHRESULT(hr);
                return BitmapDecoder(const_cast<ImagingFactory*>(this),result);
            }
        
            HWIN_EXPORT BitmapDecoder ImagingFactory::CreateDecoderFromStream( IStream *theStream, const GUID *pguidVendor, DecodeOptions metadataOptions) const
            {
                IWICBitmapDecoder* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateDecoderFromStream( theStream, pguidVendor, WICDecodeOptions(metadataOptions),&result);
                CheckHRESULT(hr);
                return BitmapDecoder(const_cast<ImagingFactory*>(this),result);
            }
            HWIN_EXPORT BitmapDecoder ImagingFactory::CreateDecoderFromStream( IStream *theStream, DecodeOptions metadataOptions) const
            {
                IWICBitmapDecoder* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateDecoderFromStream( theStream, nullptr, WICDecodeOptions(metadataOptions),&result);
                CheckHRESULT(hr);
                return BitmapDecoder(const_cast<ImagingFactory*>(this),result);
            }

            HWIN_EXPORT BitmapDecoder ImagingFactory::CreateDecoderFromFileHandle(ULONG_PTR hFile, const GUID *pguidVendor, DecodeOptions metadataOptions) const
            {
                IWICBitmapDecoder* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateDecoderFromFileHandle(hFile, pguidVendor, WICDecodeOptions(metadataOptions),&result);
                CheckHRESULT(hr);
                return BitmapDecoder(const_cast<ImagingFactory*>(this),result);
            }

            HWIN_EXPORT ComponentInfo ImagingFactory::CreateComponentInfo( REFCLSID clsidComponent) const
            {
                IWICComponentInfo* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateComponentInfo(clsidComponent,&result);
                CheckHRESULT(hr);
                return ComponentInfo(const_cast<ImagingFactory*>(this),result);
            }

            HWIN_EXPORT BitmapDecoder ImagingFactory::CreateDecoder( REFGUID guidContainerFormat, const GUID *pguidVendor) const
            {
                IWICBitmapDecoder* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateDecoder(guidContainerFormat,pguidVendor,&result);
                CheckHRESULT(hr);
                return BitmapDecoder(const_cast<ImagingFactory*>(this),result);
            }

            HWIN_EXPORT BitmapEncoder ImagingFactory::CreateEncoder( REFGUID guidContainerFormat,const GUID *pguidVendor) const
            {
                IWICBitmapEncoder* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateEncoder(guidContainerFormat,pguidVendor,&result);
                CheckHRESULT(hr);
                return BitmapEncoder(const_cast<ImagingFactory*>(this),result);
            }

            HWIN_EXPORT BitmapEncoder ImagingFactory::CreateBMPEncoder( ) const
            {
                return CreateEncoder(GUID_ContainerFormatBmp,nullptr);
            }
            HWIN_EXPORT BitmapEncoder ImagingFactory::CreatePNGEncoder( ) const
            {
                return CreateEncoder(GUID_ContainerFormatPng,nullptr);
            }
            HWIN_EXPORT BitmapEncoder ImagingFactory::CreateICOEncoder( ) const
            {
                return CreateEncoder(GUID_ContainerFormatIco,nullptr);
            }
            HWIN_EXPORT BitmapEncoder ImagingFactory::CreateJPEGEncoder( ) const
            {
                return CreateEncoder(GUID_ContainerFormatJpeg,nullptr);
            }
            HWIN_EXPORT BitmapEncoder ImagingFactory::CreateTIFFEncoder( ) const
            {
                return CreateEncoder(GUID_ContainerFormatTiff,nullptr);
            }
            HWIN_EXPORT BitmapEncoder ImagingFactory::CreateGIFEncoder( ) const
            {
                return CreateEncoder(GUID_ContainerFormatGif,nullptr);
            }
            HWIN_EXPORT BitmapEncoder ImagingFactory::CreateWMPEncoder( ) const
            {
                return CreateEncoder(GUID_ContainerFormatWmp,nullptr);
            }


            HWIN_EXPORT Palette ImagingFactory::CreatePalette( ) const
            {
                IWICPalette* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreatePalette(&result);
                CheckHRESULT(hr);
                return Palette(const_cast<ImagingFactory*>(this),result);
            }

            HWIN_EXPORT FormatConverter ImagingFactory::CreateFormatConverter( ) const
            {
                IWICFormatConverter* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateFormatConverter(&result);
                CheckHRESULT(hr);
                return FormatConverter(const_cast<ImagingFactory*>(this),result);
            }

            HWIN_EXPORT BitmapScaler ImagingFactory::CreateBitmapScaler( ) const
            {
                IWICBitmapScaler* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateBitmapScaler(&result);
                CheckHRESULT(hr);
                return BitmapScaler(const_cast<ImagingFactory*>(this),result);
            }

            HWIN_EXPORT BitmapClipper ImagingFactory::CreateBitmapClipper( ) const
            {
                IWICBitmapClipper* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateBitmapClipper(&result);
                CheckHRESULT(hr);
                return BitmapClipper(const_cast<ImagingFactory*>(this),result);
            }

            HWIN_EXPORT BitmapFlipRotator ImagingFactory::CreateBitmapFlipRotator( ) const
            {
                IWICBitmapFlipRotator* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateBitmapFlipRotator(&result);
                CheckHRESULT(hr);
                return BitmapFlipRotator(const_cast<ImagingFactory*>(this),result);
            }

            HWIN_EXPORT Stream ImagingFactory::CreateStream( ) const
            {
                IWICStream* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateStream(&result);
                CheckHRESULT(hr);
                return Stream(const_cast<ImagingFactory*>(this),result);
            }

            HWIN_EXPORT ColorContext ImagingFactory::CreateColorContext( ) const
            {
                IWICColorContext* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateColorContext(&result);
                CheckHRESULT(hr);
                return ColorContext(const_cast<ImagingFactory*>(this),result);
            }

            HWIN_EXPORT ColorTransform ImagingFactory::CreateColorTransformer( ) const
            {
                IWICColorTransform* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateColorTransformer(&result);
                CheckHRESULT(hr);
                return ColorTransform(const_cast<ImagingFactory*>(this),result);
            }

            HWIN_EXPORT Bitmap ImagingFactory::CreateBitmap( UINT uiWidth,UINT uiHeight,REFWICPixelFormatGUID pixelFormat, BitmapCreateCacheOption option) const
            {
                IWICBitmap* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateBitmap(uiWidth,uiHeight,pixelFormat, WICBitmapCreateCacheOption(option),&result);
                CheckHRESULT(hr);
                return Bitmap(const_cast<ImagingFactory*>(this),result);
            }
        
            HWIN_EXPORT Bitmap ImagingFactory::CreateBitmapFromSource( const BitmapSource& theBitmapSource,BitmapCreateCacheOption option) const
            {
                IWICBitmap* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateBitmapFromSource(theBitmapSource, WICBitmapCreateCacheOption(option),&result);
                CheckHRESULT(hr);
                return Bitmap(const_cast<ImagingFactory*>(this),result);
            }

            HWIN_EXPORT Bitmap ImagingFactory::CreateBitmapFromSourceRect( const BitmapSource& theBitmapSource,UINT x,UINT y,UINT width,UINT height) const
            {
                IWICBitmap* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateBitmapFromSourceRect(theBitmapSource, x,y,width,height,&result);
                CheckHRESULT(hr);
                return Bitmap(const_cast<ImagingFactory*>(this),result);
            }

            HWIN_EXPORT Bitmap ImagingFactory::CreateBitmapFromMemory( UINT uiWidth,UINT uiHeight,REFWICPixelFormatGUID pixelFormat,UINT cbStride,UINT cbBufferSize,BYTE *pbBuffer) const
            {
                IWICBitmap* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateBitmapFromMemory(uiWidth,uiHeight,pixelFormat,cbStride,cbBufferSize,pbBuffer,&result);
                CheckHRESULT(hr);
                return Bitmap(const_cast<ImagingFactory*>(this),result);
            }

            HWIN_EXPORT Bitmap ImagingFactory::CreateBitmapFromHBITMAP( HBITMAP hBitmap, HPALETTE hPalette, BitmapAlphaChannelOption options) const
            {
                IWICBitmap* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateBitmapFromHBITMAP( hBitmap, hPalette, WICBitmapAlphaChannelOption( options ),&result);
                CheckHRESULT(hr);
                return Bitmap(const_cast<ImagingFactory*>(this),result);
            }

            HWIN_EXPORT Bitmap ImagingFactory::CreateBitmapFromHICON(HICON hIcon) const
            {
                IWICBitmap* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateBitmapFromHICON( hIcon,&result);
                CheckHRESULT(hr);
                return Bitmap(const_cast<ImagingFactory*>(this),result);
            }

            HWIN_EXPORT const ImagingFactory& ImagingFactory::CreateComponentEnumerator( DWORD componentTypes, DWORD options, IEnumUnknown **ppIEnumUnknown) const
            {
                IWICBitmap* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateComponentEnumerator( componentTypes, options, ppIEnumUnknown);
                CheckHRESULT(hr);
                return *this;
            }

            HWIN_EXPORT FastMetadataEncoder ImagingFactory::CreateFastMetadataEncoderFromDecoder( const BitmapDecoder& theDecoder) const
            {
                IWICFastMetadataEncoder* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateFastMetadataEncoderFromDecoder( theDecoder,&result);
                CheckHRESULT(hr);
                return FastMetadataEncoder(const_cast<ImagingFactory*>(this),result);
            }

            HWIN_EXPORT FastMetadataEncoder ImagingFactory::CreateFastMetadataEncoderFromFrameDecode(const BitmapFrameDecode& theFrameDecoder) const
            {
                IWICFastMetadataEncoder* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateFastMetadataEncoderFromFrameDecode( theFrameDecoder,&result);
                CheckHRESULT(hr);
                return FastMetadataEncoder(const_cast<ImagingFactory*>(this),result);
            }

            HWIN_EXPORT MetadataQueryWriter ImagingFactory::CreateQueryWriter( REFGUID guidMetadataFormat, const GUID *pguidVendor) const
            {
                IWICMetadataQueryWriter* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateQueryWriter( guidMetadataFormat, pguidVendor,&result);
                CheckHRESULT(hr);
                return MetadataQueryWriter(const_cast<ImagingFactory*>(this),result);
            }

            HWIN_EXPORT MetadataQueryWriter ImagingFactory::CreateQueryWriterFromReader( const MetadataQueryReader& theQueryReader, const GUID *pguidVendor) const
            {
                IWICMetadataQueryWriter* result = nullptr;
                InterfaceType* pInterface = GetInterface( );
                auto hr = pInterface->CreateQueryWriterFromReader( theQueryReader, pguidVendor,&result);
                CheckHRESULT(hr);
                return MetadataQueryWriter(const_cast<ImagingFactory*>(this),result);
            }

        };
    };
};