// Created by Microsoft (R) C/C++ Compiler Version 14.16.27051.0 (4b0afb50).
//
// d:\code\logistics\smokeboxidentification\tpvs17\smokeboxidentification\x64\release\lpvCore.tli
//
// Wrapper implementations for Win32 type library c34b3e9e-6dea-4aa9-b500-0266f90dc15f
// compiler-generated file created 01/03/24 at 16:59:27 - DO NOT EDIT!

#pragma once

//
// interface ILDrawable wrapper method implementations
//

inline HRESULT ILDrawable::SetPen ( enum LPVPenStyle penStyle, int penWidth, unsigned long penColor ) {
    HRESULT _hr = raw_SetPen(penStyle, penWidth, penColor);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILDrawable::SetPenColor ( unsigned long penColor ) {
    HRESULT _hr = raw_SetPenColor(penColor);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILDrawable::SetPenWidth ( int penWidth ) {
    HRESULT _hr = raw_SetPenWidth(penWidth);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILDrawable::SetPenStyle ( enum LPVPenStyle penStyle ) {
    HRESULT _hr = raw_SetPenStyle(penStyle);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILDrawable::SetBrushColor ( unsigned long brushColor ) {
    HRESULT _hr = raw_SetBrushColor(brushColor);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILDrawable::SetFont ( _bstr_t fontFamily, int fontHeight, unsigned long fontColor, VARIANT_BOOL bold, VARIANT_BOOL italic, VARIANT_BOOL underline, VARIANT_BOOL strikeOut ) {
    HRESULT _hr = raw_SetFont(fontFamily, fontHeight, fontColor, bold, italic, underline, strikeOut);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILDrawable::SetFontFamily ( _bstr_t fontFamily ) {
    HRESULT _hr = raw_SetFontFamily(fontFamily);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILDrawable::SetFontHeight ( int fontHeight ) {
    HRESULT _hr = raw_SetFontHeight(fontHeight);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILDrawable::SetFontColor ( unsigned long fontColor ) {
    HRESULT _hr = raw_SetFontColor(fontColor);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface ILSortable wrapper method implementations
//

inline int ILSortable::GetIndex ( ) {
    int _result = 0;
    HRESULT _hr = get_Index(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILSortable::PutIndex ( int val ) {
    HRESULT _hr = put_Index(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILSortable::GetPosX ( enum LPVPositionMode posMode ) {
    double _result = 0;
    HRESULT _hr = raw_GetPosX(posMode, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILSortable::GetPosY ( enum LPVPositionMode posMode ) {
    double _result = 0;
    HRESULT _hr = raw_GetPosY(posMode, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILSortable::GetScore ( ) {
    double _result = 0;
    HRESULT _hr = raw_GetScore(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

//
// interface ILSortables wrapper method implementations
//

inline HRESULT ILSortables::Sort ( enum LPVSortBy sortBy, enum LPVSortOrder sortOrder, enum LPVPositionMode posMode ) {
    HRESULT _hr = raw_Sort(sortBy, sortOrder, posMode);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline SAFEARRAY * ILSortables::SortTo ( enum LPVSortBy sortBy, enum LPVSortOrder sortOrder, enum LPVPositionMode posMode ) {
    SAFEARRAY * _result = 0;
    HRESULT _hr = raw_SortTo(sortBy, sortOrder, posMode, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILSortables::ApplySort ( SAFEARRAY * sortedIndexes ) {
    HRESULT _hr = raw_ApplySort(sortedIndexes);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline int ILSortables::SortableCount ( ) {
    int _result = 0;
    HRESULT _hr = raw_SortableCount(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline ILSortablePtr ILSortables::GetSortable ( int Index ) {
    struct ILSortable * _result = 0;
    HRESULT _hr = raw_GetSortable(Index, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILSortablePtr(_result, false);
}

//
// interface ILObject wrapper method implementations
//

inline HRESULT ILObject::Reset ( ) {
    HRESULT _hr = raw_Reset();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline enum LPVErrorCode ILObject::Save ( _bstr_t filename ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_Save(filename, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline enum LPVErrorCode ILObject::Load ( _bstr_t filename ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_Load(filename, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

//
// interface ILSystem wrapper method implementations
//

inline VARIANT_BOOL ILSystem::CheckVersion ( long majorVersion, long minorVersion, long microVersion ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_CheckVersion(majorVersion, minorVersion, microVersion, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILSystem::SetPen ( IDispatch * drawable, enum LPVPenStyle penStyle, int penWidth, unsigned long penColor ) {
    HRESULT _hr = raw_SetPen(drawable, penStyle, penWidth, penColor);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILSystem::SetPenColor ( IDispatch * drawable, unsigned long penColor ) {
    HRESULT _hr = raw_SetPenColor(drawable, penColor);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILSystem::SetPenWidth ( IDispatch * drawable, int penWidth ) {
    HRESULT _hr = raw_SetPenWidth(drawable, penWidth);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILSystem::SetPenStyle ( IDispatch * drawable, enum LPVPenStyle penStyle ) {
    HRESULT _hr = raw_SetPenStyle(drawable, penStyle);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILSystem::SetBrushColor ( IDispatch * drawable, unsigned long penColor ) {
    HRESULT _hr = raw_SetBrushColor(drawable, penColor);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILSystem::SetFont ( IDispatch * drawable, _bstr_t fontFamily, int fontHeight, unsigned long fontColor, VARIANT_BOOL bold, VARIANT_BOOL italic, VARIANT_BOOL underline, VARIANT_BOOL strikeOut ) {
    HRESULT _hr = raw_SetFont(drawable, fontFamily, fontHeight, fontColor, bold, italic, underline, strikeOut);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILSystem::SetFontFamily ( IDispatch * drawable, _bstr_t fontFamily ) {
    HRESULT _hr = raw_SetFontFamily(drawable, fontFamily);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILSystem::SetFontHeight ( IDispatch * drawable, int fontHeight ) {
    HRESULT _hr = raw_SetFontHeight(drawable, fontHeight);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILSystem::SetFontColor ( IDispatch * drawable, unsigned long fontColor ) {
    HRESULT _hr = raw_SetFontColor(drawable, fontColor);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline unsigned long ILSystem::GetColorRef ( int red, int green, int blue ) {
    unsigned long _result = 0;
    HRESULT _hr = raw_GetColorRef(red, green, blue, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILSystem::SetDrawPointSize ( int size ) {
    HRESULT _hr = raw_SetDrawPointSize(size);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILSystem::DrawPoint ( double x, double y, enum LPVPointShape shape, void * hdc, double zoomX, double zoomY, double panX, double panY ) {
    HRESULT _hr = raw_DrawPoint(x, y, shape, hdc, zoomX, zoomY, panX, panY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILSystem::DrawLine ( double x1, double y1, double x2, double y2, void * hdc, double zoomX, double zoomY, double panX, double panY ) {
    HRESULT _hr = raw_DrawLine(x1, y1, x2, y2, hdc, zoomX, zoomY, panX, panY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILSystem::DrawCircle ( double x, double y, double r, VARIANT_BOOL bFill, void * hdc, double zoomX, double zoomY, double panX, double panY ) {
    HRESULT _hr = raw_DrawCircle(x, y, r, bFill, hdc, zoomX, zoomY, panX, panY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILSystem::DrawRect ( double x, double y, double w, double h, double a, VARIANT_BOOL bFill, void * hdc, double zoomX, double zoomY, double panX, double panY ) {
    HRESULT _hr = raw_DrawRect(x, y, w, h, a, bFill, hdc, zoomX, zoomY, panX, panY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILSystem::DrawPolygon ( SAFEARRAY * xs, SAFEARRAY * ys, VARIANT_BOOL bClosed, VARIANT_BOOL bFill, void * hdc, double zoomX, double zoomY, double panX, double panY ) {
    HRESULT _hr = raw_DrawPolygon(xs, ys, bClosed, bFill, hdc, zoomX, zoomY, panX, panY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILSystem::DrawString ( _bstr_t text, int tlx, int tly, void * hdc, double zoomX, double zoomY, double panX, double panY ) {
    HRESULT _hr = raw_DrawString(text, tlx, tly, hdc, zoomX, zoomY, panX, panY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILSystem::GetRGBFromColorRef ( unsigned long colorRef, int * red, int * green, int * blue ) {
    HRESULT _hr = raw_GetRGBFromColorRef(colorRef, red, green, blue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILSystem::SetRegionHandleSize ( int size ) {
    HRESULT _hr = raw_SetRegionHandleSize(size);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline VARIANT_BOOL ILSystem::CheckLicense ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_CheckLicense(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline VARIANT_BOOL ILSystem::CheckLib ( _bstr_t libName ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_CheckLib(libName, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

//
// interface ILImage wrapper method implementations
//

inline enum LPVImageFormat ILImage::GetImageFormat ( ) {
    enum LPVImageFormat _result;
    HRESULT _hr = get_ImageFormat(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILImage::PutImageFormat ( enum LPVImageFormat val ) {
    HRESULT _hr = put_ImageFormat(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline int ILImage::GetWidth ( ) {
    int _result = 0;
    HRESULT _hr = get_Width(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline int ILImage::GetHeight ( ) {
    int _result = 0;
    HRESULT _hr = get_Height(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline int ILImage::GetBytesPerLine ( ) {
    int _result = 0;
    HRESULT _hr = get_BytesPerLine(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void * ILImage::GetDataPointer ( ) {
    void * _result = 0;
    HRESULT _hr = get_DataPointer(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILImage::SetSize ( int w, int h ) {
    HRESULT _hr = raw_SetSize(w, h);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline int ILImage::GetPixel ( int x, int y ) {
    int _result = 0;
    HRESULT _hr = get_Pixel(x, y, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILImage::PutPixel ( int x, int y, int val ) {
    HRESULT _hr = put_Pixel(x, y, val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL ILImage::Void ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_Void(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILImage::SetImageData ( int w, int h, void * dataPtr, int bpl, VARIANT_BOOL copyData ) {
    HRESULT _hr = raw_SetImageData(w, h, dataPtr, bpl, copyData);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImage::CopyTo ( struct ILImage * dstImg ) {
    HRESULT _hr = raw_CopyTo(dstImg);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImage::CopyFrom ( struct ILImage * img, struct ILRegion * region, int panX, int panY ) {
    HRESULT _hr = raw_CopyFrom(img, region, panX, panY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline enum LPVErrorCode ILImage::Save ( _bstr_t filename, struct ILRegion * region ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_Save(filename, region, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILImage::Draw ( void * hdc, double zoomX, double zoomY, double panX, double panY ) {
    HRESULT _hr = raw_Draw(hdc, zoomX, zoomY, panX, panY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImage::DrawAsMask ( void * hdc, double zoomX, double zoomY, double panX, double panY ) {
    HRESULT _hr = raw_DrawAsMask(hdc, zoomX, zoomY, panX, panY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline struct LColor ILImage::GetPixelColor ( int x, int y ) {
    struct LColor _result;
    HRESULT _hr = get_PixelColor(x, y, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILImage::PutPixelColor ( int x, int y, struct LColor val ) {
    HRESULT _hr = put_PixelColor(x, y, val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT ILImage::SetTo ( int val, struct ILRegion * region ) {
    HRESULT _hr = raw_SetTo(val, region);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImage::SetToColor ( struct LColor val, struct ILRegion * region ) {
    HRESULT _hr = raw_SetToColor(val, region);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline ILImagePtr ILImage::GetChannel ( int channelIdx ) {
    struct ILImage * _result = 0;
    HRESULT _hr = raw_GetChannel(channelIdx, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILImagePtr(_result, false);
}

inline HRESULT ILImage::SetChannel ( int channelIdx, struct ILImage * channelImage ) {
    HRESULT _hr = raw_SetChannel(channelIdx, channelImage);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface ILRegion wrapper method implementations
//

inline HRESULT ILRegion::Draw ( void * hdc, VARIANT_BOOL drawHandles, double zoomX, double zoomY, double panX, double panY ) {
    HRESULT _hr = raw_Draw(hdc, drawHandles, zoomX, zoomY, panX, panY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline enum LPVRoiHandle ILRegion::HitTest ( int x, int y, double zoomX, double zoomY, double panX, double panY ) {
    enum LPVRoiHandle _result;
    HRESULT _hr = raw_HitTest(x, y, zoomX, zoomY, panX, panY, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILRegion::Drag ( enum LPVRoiHandle roiHandle, int x, int y, double zoomX, double zoomY, double panX, double panY ) {
    HRESULT _hr = raw_Drag(roiHandle, x, y, zoomX, zoomY, panX, panY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILRegion::EnableHandle ( enum LPVRoiHandle roiHandle, VARIANT_BOOL enabled ) {
    HRESULT _hr = raw_EnableHandle(roiHandle, enabled);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline ILRegionPtr ILRegion::Add ( struct ILRegion * other ) {
    struct ILRegion * _result = 0;
    HRESULT _hr = raw_Add(other, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILRegionPtr(_result, false);
}

inline ILRegionPtr ILRegion::Subtract ( struct ILRegion * other ) {
    struct ILRegion * _result = 0;
    HRESULT _hr = raw_Subtract(other, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILRegionPtr(_result, false);
}

inline ILRegionPtr ILRegion::Union ( struct ILRegion * other ) {
    struct ILRegion * _result = 0;
    HRESULT _hr = raw_Union(other, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILRegionPtr(_result, false);
}

inline VARIANT_BOOL ILRegion::Void ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_Void(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILRegion::ReduceImage ( struct ILImage * image, struct ILImage * * newImage, struct ILImage * * newMask ) {
    HRESULT _hr = raw_ReduceImage(image, newImage, newMask);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILRegion::MapFromImage ( double imagePointX, double imagePointY, double * regionPointX, double * regionPointY ) {
    HRESULT _hr = raw_MapFromImage(imagePointX, imagePointY, regionPointX, regionPointY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILRegion::MapToImage ( double regionPointX, double regionPointY, double * imagePointX, double * imagePointY ) {
    HRESULT _hr = raw_MapToImage(regionPointX, regionPointY, imagePointX, imagePointY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline IDispatchPtr ILRegion::MapObjectFromImage ( IDispatch * imageObject ) {
    IDispatch * _result = 0;
    HRESULT _hr = raw_MapObjectFromImage(imageObject, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IDispatchPtr(_result, false);
}

inline IDispatchPtr ILRegion::MapObjectToImage ( IDispatch * regionObject ) {
    IDispatch * _result = 0;
    HRESULT _hr = raw_MapObjectToImage(regionObject, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IDispatchPtr(_result, false);
}

inline ILRegionPtr ILRegion::Translate ( double offsetX, double offsetY ) {
    struct ILRegion * _result = 0;
    HRESULT _hr = raw_Translate(offsetX, offsetY, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILRegionPtr(_result, false);
}

inline ILRegionPtr ILRegion::Scale ( double factorX, double factorY ) {
    struct ILRegion * _result = 0;
    HRESULT _hr = raw_Scale(factorX, factorY, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILRegionPtr(_result, false);
}

inline ILRegionPtr ILRegion::Rotate ( double da ) {
    struct ILRegion * _result = 0;
    HRESULT _hr = raw_Rotate(da, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILRegionPtr(_result, false);
}

inline ILRegionPtr ILRegion::RotateAndTranslate ( double x, double y, double newX, double newY, double da ) {
    struct ILRegion * _result = 0;
    HRESULT _hr = raw_RotateAndTranslate(x, y, newX, newY, da, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILRegionPtr(_result, false);
}

inline ILImagePtr ILRegion::ToMask ( int w, int h ) {
    struct ILImage * _result = 0;
    HRESULT _hr = raw_ToMask(w, h, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILImagePtr(_result, false);
}

inline ILRegionPtr ILRegion::Intersect ( struct ILRegion * other ) {
    struct ILRegion * _result = 0;
    HRESULT _hr = raw_Intersect(other, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILRegionPtr(_result, false);
}

inline ILRegionPtr ILRegion::XOR ( struct ILRegion * other ) {
    struct ILRegion * _result = 0;
    HRESULT _hr = raw_XOR(other, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILRegionPtr(_result, false);
}

inline ILRegionPtr ILRegion::Copy ( ) {
    struct ILRegion * _result = 0;
    HRESULT _hr = raw_Copy(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILRegionPtr(_result, false);
}

inline ILRegionPtr ILRegion::Invert ( ) {
    struct ILRegion * _result = 0;
    HRESULT _hr = raw_Invert(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILRegionPtr(_result, false);
}

inline double ILRegion::GetReduceAngle ( ) {
    double _result = 0;
    HRESULT _hr = get_ReduceAngle(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILRegion::PutReduceAngle ( double val ) {
    HRESULT _hr = put_ReduceAngle(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILRegion::GetReduceScale ( ) {
    double _result = 0;
    HRESULT _hr = get_ReduceScale(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILRegion::PutReduceScale ( double val ) {
    HRESULT _hr = put_ReduceScale(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline enum LPVInterpolationMethod ILRegion::GetInterpolationMethod ( ) {
    enum LPVInterpolationMethod _result;
    HRESULT _hr = get_InterpolationMethod(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILRegion::PutInterpolationMethod ( enum LPVInterpolationMethod val ) {
    HRESULT _hr = put_InterpolationMethod(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

//
// interface ILRectRegion wrapper method implementations
//

inline double ILRectRegion::GetLeft ( ) {
    double _result = 0;
    HRESULT _hr = get_Left(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILRectRegion::PutLeft ( double val ) {
    HRESULT _hr = put_Left(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILRectRegion::GetTop ( ) {
    double _result = 0;
    HRESULT _hr = get_Top(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILRectRegion::PutTop ( double val ) {
    HRESULT _hr = put_Top(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILRectRegion::GetWidth ( ) {
    double _result = 0;
    HRESULT _hr = get_Width(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILRectRegion::PutWidth ( double val ) {
    HRESULT _hr = put_Width(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILRectRegion::GetHeight ( ) {
    double _result = 0;
    HRESULT _hr = get_Height(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILRectRegion::PutHeight ( double val ) {
    HRESULT _hr = put_Height(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT ILRectRegion::SetPlacement ( double tlx, double tly, double w, double h ) {
    HRESULT _hr = raw_SetPlacement(tlx, tly, w, h);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline double ILRectRegion::GetCenterX ( ) {
    double _result = 0;
    HRESULT _hr = get_CenterX(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILRectRegion::GetCenterY ( ) {
    double _result = 0;
    HRESULT _hr = get_CenterY(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

//
// interface ILRotRectRegion wrapper method implementations
//

inline double ILRotRectRegion::GetCenterX ( ) {
    double _result = 0;
    HRESULT _hr = get_CenterX(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILRotRectRegion::PutCenterX ( double val ) {
    HRESULT _hr = put_CenterX(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILRotRectRegion::GetCenterY ( ) {
    double _result = 0;
    HRESULT _hr = get_CenterY(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILRotRectRegion::PutCenterY ( double val ) {
    HRESULT _hr = put_CenterY(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILRotRectRegion::GetWidth ( ) {
    double _result = 0;
    HRESULT _hr = get_Width(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILRotRectRegion::PutWidth ( double val ) {
    HRESULT _hr = put_Width(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILRotRectRegion::GetHeight ( ) {
    double _result = 0;
    HRESULT _hr = get_Height(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILRotRectRegion::PutHeight ( double val ) {
    HRESULT _hr = put_Height(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILRotRectRegion::GetAngle ( ) {
    double _result = 0;
    HRESULT _hr = get_Angle(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILRotRectRegion::PutAngle ( double val ) {
    HRESULT _hr = put_Angle(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT ILRotRectRegion::SetPlacement ( double cenx, double ceny, double w, double h, double a ) {
    HRESULT _hr = raw_SetPlacement(cenx, ceny, w, h, a);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface ILCircleRegion wrapper method implementations
//

inline double ILCircleRegion::GetCenterX ( ) {
    double _result = 0;
    HRESULT _hr = get_CenterX(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCircleRegion::PutCenterX ( double val ) {
    HRESULT _hr = put_CenterX(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILCircleRegion::GetCenterY ( ) {
    double _result = 0;
    HRESULT _hr = get_CenterY(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCircleRegion::PutCenterY ( double val ) {
    HRESULT _hr = put_CenterY(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILCircleRegion::GetRadius ( ) {
    double _result = 0;
    HRESULT _hr = get_Radius(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCircleRegion::PutRadius ( double val ) {
    HRESULT _hr = put_Radius(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT ILCircleRegion::SetPlacement ( double cenx, double ceny, double r ) {
    HRESULT _hr = raw_SetPlacement(cenx, ceny, r);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface ILPolyRegion wrapper method implementations
//

inline int ILPolyRegion::CtrlCount ( ) {
    int _result = 0;
    HRESULT _hr = raw_CtrlCount(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILPolyRegion::AddCtrl ( double x, double y, int ctrlIndex ) {
    HRESULT _hr = raw_AddCtrl(x, y, ctrlIndex);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILPolyRegion::GetCtrl ( int ctrlIndex, double * x, double * y ) {
    HRESULT _hr = raw_GetCtrl(ctrlIndex, x, y);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILPolyRegion::SetPlacement ( SAFEARRAY * xs, SAFEARRAY * ys ) {
    HRESULT _hr = raw_SetPlacement(xs, ys);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILPolyRegion::RemoveCtrl ( int ctrlIndex ) {
    HRESULT _hr = raw_RemoveCtrl(ctrlIndex);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILPolyRegion::SetCtrl ( double x, double y, int ctrlIndex ) {
    HRESULT _hr = raw_SetCtrl(x, y, ctrlIndex);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface ILMaskRegion wrapper method implementations
//

inline HRESULT ILMaskRegion::SetMask ( struct ILImage * mask, double tlx, double tly ) {
    HRESULT _hr = raw_SetMask(mask, tlx, tly);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface ILAnnulusRegion wrapper method implementations
//

inline double ILAnnulusRegion::GetCenterX ( ) {
    double _result = 0;
    HRESULT _hr = get_CenterX(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILAnnulusRegion::PutCenterX ( double val ) {
    HRESULT _hr = put_CenterX(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILAnnulusRegion::GetCenterY ( ) {
    double _result = 0;
    HRESULT _hr = get_CenterY(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILAnnulusRegion::PutCenterY ( double val ) {
    HRESULT _hr = put_CenterY(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILAnnulusRegion::GetInnerRadius ( ) {
    double _result = 0;
    HRESULT _hr = get_InnerRadius(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILAnnulusRegion::PutInnerRadius ( double val ) {
    HRESULT _hr = put_InnerRadius(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILAnnulusRegion::GetOuterRadius ( ) {
    double _result = 0;
    HRESULT _hr = get_OuterRadius(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILAnnulusRegion::PutOuterRadius ( double val ) {
    HRESULT _hr = put_OuterRadius(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT ILAnnulusRegion::SetPlacement ( double cenx, double ceny, double rInner, double rOuter ) {
    HRESULT _hr = raw_SetPlacement(cenx, ceny, rInner, rOuter);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface ILEllipseRegion wrapper method implementations
//

inline double ILEllipseRegion::GetCenterX ( ) {
    double _result = 0;
    HRESULT _hr = get_CenterX(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILEllipseRegion::PutCenterX ( double val ) {
    HRESULT _hr = put_CenterX(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILEllipseRegion::GetCenterY ( ) {
    double _result = 0;
    HRESULT _hr = get_CenterY(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILEllipseRegion::PutCenterY ( double val ) {
    HRESULT _hr = put_CenterY(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILEllipseRegion::GetWidth ( ) {
    double _result = 0;
    HRESULT _hr = get_Width(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILEllipseRegion::PutWidth ( double val ) {
    HRESULT _hr = put_Width(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILEllipseRegion::GetHeight ( ) {
    double _result = 0;
    HRESULT _hr = get_Height(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILEllipseRegion::PutHeight ( double val ) {
    HRESULT _hr = put_Height(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILEllipseRegion::GetAngle ( ) {
    double _result = 0;
    HRESULT _hr = get_Angle(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILEllipseRegion::PutAngle ( double val ) {
    HRESULT _hr = put_Angle(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT ILEllipseRegion::SetPlacement ( double cenx, double ceny, double w, double h, double a ) {
    HRESULT _hr = raw_SetPlacement(cenx, ceny, w, h, a);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface ILAnnulusSectorRegion wrapper method implementations
//

inline double ILAnnulusSectorRegion::GetCenterX ( ) {
    double _result = 0;
    HRESULT _hr = get_CenterX(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILAnnulusSectorRegion::PutCenterX ( double val ) {
    HRESULT _hr = put_CenterX(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILAnnulusSectorRegion::GetCenterY ( ) {
    double _result = 0;
    HRESULT _hr = get_CenterY(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILAnnulusSectorRegion::PutCenterY ( double val ) {
    HRESULT _hr = put_CenterY(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILAnnulusSectorRegion::GetInnerRadius ( ) {
    double _result = 0;
    HRESULT _hr = get_InnerRadius(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILAnnulusSectorRegion::PutInnerRadius ( double val ) {
    HRESULT _hr = put_InnerRadius(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILAnnulusSectorRegion::GetOuterRadius ( ) {
    double _result = 0;
    HRESULT _hr = get_OuterRadius(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILAnnulusSectorRegion::PutOuterRadius ( double val ) {
    HRESULT _hr = put_OuterRadius(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILAnnulusSectorRegion::GetStartAngle ( ) {
    double _result = 0;
    HRESULT _hr = get_StartAngle(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILAnnulusSectorRegion::PutStartAngle ( double val ) {
    HRESULT _hr = put_StartAngle(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILAnnulusSectorRegion::GetEndAngle ( ) {
    double _result = 0;
    HRESULT _hr = get_EndAngle(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILAnnulusSectorRegion::PutEndAngle ( double val ) {
    HRESULT _hr = put_EndAngle(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT ILAnnulusSectorRegion::SetPlacement ( double cenx, double ceny, double rInner, double rOuter, double aStart, double aEnd ) {
    HRESULT _hr = raw_SetPlacement(cenx, ceny, rInner, rOuter, aStart, aEnd);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface ILImageList wrapper method implementations
//

inline int ILImageList::GetMaxCount ( ) {
    int _result = 0;
    HRESULT _hr = get_MaxCount(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILImageList::PutMaxCount ( int val ) {
    HRESULT _hr = put_MaxCount(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT ILImageList::Reset ( ) {
    HRESULT _hr = raw_Reset();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline int ILImageList::Count ( ) {
    int _result = 0;
    HRESULT _hr = raw_Count(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILImageList::Add ( struct ILImage * img, struct ILRectRegion * region ) {
    HRESULT _hr = raw_Add(img, region);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageList::Adds ( SAFEARRAY * images ) {
    HRESULT _hr = raw_Adds(images);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline ILImagePtr ILImageList::Item ( int imgIndex ) {
    struct ILImage * _result = 0;
    HRESULT _hr = raw_Item(imgIndex, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILImagePtr(_result, false);
}

inline VARIANT_BOOL ILImageList::GetUseCache ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_UseCache(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILImageList::PutUseCache ( VARIANT_BOOL val ) {
    HRESULT _hr = put_UseCache(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL ILImageList::GetSameSize ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_SameSize(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILImageList::PutSameSize ( VARIANT_BOOL val ) {
    HRESULT _hr = put_SameSize(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}