smokeboxidentification/tpvs17/SmokeBoxIdentification/x64/Release/lpvGeom.tli

// Created by Microsoft (R) C/C++ Compiler Version 14.16.27050.0 (c21ddf40).
//
// d:\git\hzleaper\smokebox\tpvs17\smokeboxidentification\x64\release\lpvGeom.tli
//
// Wrapper implementations for type library 8955aafb-4602-4d6a-a888-69d1437c4d2b
// compiler-generated file created 03/05/24 at 14:34:41 - DO NOT EDIT!

#pragma once

//
// interface ILLine wrapper method implementations
//

inline double ILLine::GetX1 ( ) {
    double _result = 0;
    HRESULT _hr = get_X1(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILLine::PutX1 ( double val ) {
    HRESULT _hr = put_X1(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILLine::GetY1 ( ) {
    double _result = 0;
    HRESULT _hr = get_Y1(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILLine::PutY1 ( double val ) {
    HRESULT _hr = put_Y1(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILLine::GetX2 ( ) {
    double _result = 0;
    HRESULT _hr = get_X2(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILLine::PutX2 ( double val ) {
    HRESULT _hr = put_X2(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILLine::GetY2 ( ) {
    double _result = 0;
    HRESULT _hr = get_Y2(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILLine::PutY2 ( double val ) {
    HRESULT _hr = put_Y2(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL ILLine::Valid ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_Valid(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILLine::Set ( double X1, double Y1, double X2, double Y2 ) {
    HRESULT _hr = raw_Set(X1, Y1, X2, Y2);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILLine::Set2 ( double midx, double midy, double lineAngle, double length ) {
    HRESULT _hr = raw_Set2(midx, midy, lineAngle, length);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILLine::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 ILPointPtr ILLine::GetMidPoint ( ) {
    struct ILPoint * _result = 0;
    HRESULT _hr = raw_GetMidPoint(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointPtr(_result, false);
}

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

inline double ILLine::GetLength ( ) {
    double _result = 0;
    HRESULT _hr = raw_GetLength(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline enum LPVIntersectType ILLine::IntersectLine ( struct ILLine * line, struct ILPoint * * intersectPoint ) {
    enum LPVIntersectType _result;
    HRESULT _hr = raw_IntersectLine(line, intersectPoint, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline enum LPVIntersectType ILLine::IntersectCircle ( struct ILCircle * circle, struct ILPoints * * intersectPoints ) {
    enum LPVIntersectType _result;
    HRESULT _hr = raw_IntersectCircle(circle, intersectPoints, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline enum LPVIntersectType ILLine::IntersectPoly ( struct ILPolygon * polygon, struct ILPoints * * intersectPoints ) {
    enum LPVIntersectType _result;
    HRESULT _hr = raw_IntersectPoly(polygon, intersectPoints, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILLine::Perpendicular ( struct ILPoint * point, struct ILPoint * * rootPoint ) {
    double _result = 0;
    HRESULT _hr = raw_Perpendicular(point, rootPoint, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline ILLinePtr ILLine::BisectLine ( struct ILLine * line ) {
    struct ILLine * _result = 0;
    HRESULT _hr = raw_BisectLine(line, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILLinePtr(_result, false);
}

inline double ILLine::Distance ( struct ILLine * line ) {
    double _result = 0;
    HRESULT _hr = raw_Distance(line, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILLine::AcuteAngle ( struct ILLine * line ) {
    double _result = 0;
    HRESULT _hr = raw_AcuteAngle(line, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILLine::Parallel ( struct ILLine * line ) {
    double _result = 0;
    HRESULT _hr = raw_Parallel(line, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILLine::AngleTo ( struct ILLine * line ) {
    double _result = 0;
    HRESULT _hr = raw_AngleTo(line, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

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

inline ILLinePtr ILLine::Transform ( struct ILTransform * tf ) {
    struct ILLine * _result = 0;
    HRESULT _hr = raw_Transform(tf, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILLinePtr(_result, false);
}

inline ILRotRectRegionPtr ILLine::ToRotRectRegion ( int exp ) {
    struct ILRotRectRegion * _result = 0;
    HRESULT _hr = raw_ToRotRectRegion(exp, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILRotRectRegionPtr(_result, false);
}

inline HRESULT ILLine::FromRotRectRegion ( struct ILRotRectRegion * val ) {
    HRESULT _hr = raw_FromRotRectRegion(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline ILPolygonPtr ILLine::Resample ( int num ) {
    struct ILPolygon * _result = 0;
    HRESULT _hr = raw_Resample(num, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPolygonPtr(_result, false);
}

inline ILPolygonPtr ILLine::ResampleByStep ( double step, double stepThreshold ) {
    struct ILPolygon * _result = 0;
    HRESULT _hr = raw_ResampleByStep(step, stepThreshold, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPolygonPtr(_result, false);
}

inline double ILLine::GetX ( double Y ) {
    double _result = 0;
    HRESULT _hr = raw_GetX(Y, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILLine::GetY ( double X ) {
    double _result = 0;
    HRESULT _hr = raw_GetY(X, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

//
// interface ILPoint wrapper method implementations
//

inline double ILPoint::GetX ( ) {
    double _result = 0;
    HRESULT _hr = get_X(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILPoint::PutX ( double val ) {
    HRESULT _hr = put_X(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILPoint::GetY ( ) {
    double _result = 0;
    HRESULT _hr = get_Y(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILPoint::PutY ( double val ) {
    HRESULT _hr = put_Y(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL ILPoint::Valid ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_Valid(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILPoint::Set ( double X, double Y ) {
    HRESULT _hr = raw_Set(X, Y);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

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

inline ILPointPtr ILPoint::MidPoint ( struct ILPoint * point ) {
    struct ILPoint * _result = 0;
    HRESULT _hr = raw_MidPoint(point, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointPtr(_result, false);
}

inline double ILPoint::DotProduct ( struct ILPoint * point ) {
    double _result = 0;
    HRESULT _hr = raw_DotProduct(point, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILPoint::Distance ( struct ILPoint * point ) {
    double _result = 0;
    HRESULT _hr = raw_Distance(point, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILPoint::DistanceWithRefLine ( struct ILPoint * point, struct ILLine * refLine ) {
    double _result = 0;
    HRESULT _hr = raw_DistanceWithRefLine(point, refLine, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILPoint::Collinear ( struct ILPoint * point1, struct ILPoint * point2 ) {
    double _result = 0;
    HRESULT _hr = raw_Collinear(point1, point2, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

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

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

inline ILPointPtr ILPoint::Transform ( struct ILTransform * tf ) {
    struct ILPoint * _result = 0;
    HRESULT _hr = raw_Transform(tf, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointPtr(_result, false);
}

inline HRESULT ILPoint::FromSortable ( struct ILSortable * obj, enum LPVPositionMode posMode ) {
    HRESULT _hr = raw_FromSortable(obj, posMode);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface ILTransform wrapper method implementations
//

inline struct LMatrix33 ILTransform::GetMatrix ( ) {
    struct LMatrix33 _result;
    HRESULT _hr = get_Matrix(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILTransform::PutMatrix ( struct LMatrix33 val ) {
    HRESULT _hr = put_Matrix(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

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

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

inline ILTransformPtr ILTransform::Rotate ( double da, enum LPVAxis axis ) {
    struct ILTransform * _result = 0;
    HRESULT _hr = raw_Rotate(da, axis, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILTransformPtr(_result, false);
}

inline ILTransformPtr ILTransform::Transform ( struct ILTransform * tf ) {
    struct ILTransform * _result = 0;
    HRESULT _hr = raw_Transform(tf, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILTransformPtr(_result, false);
}

inline double ILTransform::Build ( struct ILPoints * srcPoints, struct ILPoints * dstPoints, enum LPVTransformType type ) {
    double _result = 0;
    HRESULT _hr = raw_Build(srcPoints, dstPoints, type, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

//
// interface ILPoints wrapper method implementations
//

inline VARIANT_BOOL ILPoints::Valid ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_Valid(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

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

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

inline ILPointPtr ILPoints::Item ( int index ) {
    struct ILPoint * _result = 0;
    HRESULT _hr = raw_Item(index, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointPtr(_result, false);
}

inline HRESULT ILPoints::Add ( double X, double Y ) {
    HRESULT _hr = raw_Add(X, Y);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

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

inline HRESULT ILPoints::SetPoints ( SAFEARRAY * xs, SAFEARRAY * ys ) {
    HRESULT _hr = raw_SetPoints(xs, ys);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILPoints::AddPoints ( struct ILPoints * points ) {
    HRESULT _hr = raw_AddPoints(points);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILPoints::RemovePoints ( double lbX, double ubX, double lbY, double ubY ) {
    HRESULT _hr = raw_RemovePoints(lbX, ubX, lbY, ubY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILPoints::GetPoints ( SAFEARRAY * xs, SAFEARRAY * ys ) {
    HRESULT _hr = raw_GetPoints(xs, ys);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline ILRectPtr ILPoints::GetBoundingRect ( ) {
    struct ILRect * _result = 0;
    HRESULT _hr = raw_GetBoundingRect(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILRectPtr(_result, false);
}

inline ILRectPtr ILPoints::GetBoundingRotRect ( ) {
    struct ILRect * _result = 0;
    HRESULT _hr = raw_GetBoundingRotRect(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILRectPtr(_result, false);
}

inline ILCirclePtr ILPoints::GetBoundingCircle ( ) {
    struct ILCircle * _result = 0;
    HRESULT _hr = raw_GetBoundingCircle(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILCirclePtr(_result, false);
}

inline ILPolygonPtr ILPoints::GetConvexHull ( ) {
    struct ILPolygon * _result = 0;
    HRESULT _hr = raw_GetConvexHull(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPolygonPtr(_result, false);
}

inline ILLinePtr ILPoints::FitLine ( double fitDistThreshold, int fitCountThreshold ) {
    struct ILLine * _result = 0;
    HRESULT _hr = raw_FitLine(fitDistThreshold, fitCountThreshold, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILLinePtr(_result, false);
}

inline ILCirclePtr ILPoints::FitCircle ( double fitDistThreshold, int fitCountThreshold ) {
    struct ILCircle * _result = 0;
    HRESULT _hr = raw_FitCircle(fitDistThreshold, fitCountThreshold, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILCirclePtr(_result, false);
}

inline ILEllipsePtr ILPoints::FitEllipse ( ) {
    struct ILEllipse * _result = 0;
    HRESULT _hr = raw_FitEllipse(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILEllipsePtr(_result, false);
}

inline ILPointPtr ILPoints::GetCenter ( ) {
    struct ILPoint * _result = 0;
    HRESULT _hr = raw_GetCenter(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointPtr(_result, false);
}

inline SAFEARRAY * ILPoints::DistancesToPoint ( struct ILPoint * point ) {
    SAFEARRAY * _result = 0;
    HRESULT _hr = raw_DistancesToPoint(point, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline SAFEARRAY * ILPoints::DistancesToLine ( struct ILLine * line ) {
    SAFEARRAY * _result = 0;
    HRESULT _hr = raw_DistancesToLine(line, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline SAFEARRAY * ILPoints::DistancesToPolygon ( struct ILPolygon * polygon, SAFEARRAY * * rootPoints ) {
    SAFEARRAY * _result = 0;
    HRESULT _hr = raw_DistancesToPolygon(polygon, rootPoints, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline SAFEARRAY * ILPoints::DistancesToPoints ( struct ILPoints * points, SAFEARRAY * * indexes ) {
    SAFEARRAY * _result = 0;
    HRESULT _hr = raw_DistancesToPoints(points, indexes, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILPoints::DistanceToPoint ( struct ILPoint * point, enum LPVAggregation aggType ) {
    double _result = 0;
    HRESULT _hr = raw_DistanceToPoint(point, aggType, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILPoints::DistanceToLine ( struct ILLine * line, enum LPVAggregation aggType ) {
    double _result = 0;
    HRESULT _hr = raw_DistanceToLine(line, aggType, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILPoints::DistanceToPolygon ( struct ILPolygon * polygon, enum LPVAggregation aggType ) {
    double _result = 0;
    HRESULT _hr = raw_DistanceToPolygon(polygon, aggType, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILPoints::DistanceToPoints ( struct ILPoints * points, enum LPVAggregation aggType ) {
    double _result = 0;
    HRESULT _hr = raw_DistanceToPoints(points, aggType, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

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

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

inline ILPointsPtr ILPoints::Transform ( struct ILTransform * tf ) {
    struct ILPoints * _result = 0;
    HRESULT _hr = raw_Transform(tf, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointsPtr(_result, false);
}

inline HRESULT ILPoints::AddPointsInRegion ( struct ILRegion * region ) {
    HRESULT _hr = raw_AddPointsInRegion(region);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILPoints::FromSortables ( struct ILSortables * obj, enum LPVPositionMode posMode ) {
    HRESULT _hr = raw_FromSortables(obj, posMode);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface ILRect wrapper method implementations
//

inline double ILRect::GetX ( ) {
    double _result = 0;
    HRESULT _hr = get_X(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILRect::PutX ( double val ) {
    HRESULT _hr = put_X(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILRect::GetY ( ) {
    double _result = 0;
    HRESULT _hr = get_Y(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILRect::PutY ( double val ) {
    HRESULT _hr = put_Y(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

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

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

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

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

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

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

inline VARIANT_BOOL ILRect::Valid ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_Valid(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILRect::Set ( double X, double Y, double w, double h, double a ) {
    HRESULT _hr = raw_Set(X, Y, w, h, a);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

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

inline ILRectPtr ILRect::Adjust ( double dtop, double dbottom, double dleft, double dright ) {
    struct ILRect * _result = 0;
    HRESULT _hr = raw_Adjust(dtop, dbottom, dleft, dright, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILRectPtr(_result, false);
}

inline ILPointPtr ILRect::GetCenter ( ) {
    struct ILPoint * _result = 0;
    HRESULT _hr = raw_GetCenter(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointPtr(_result, false);
}

inline ILPointPtr ILRect::GetTopLeft ( ) {
    struct ILPoint * _result = 0;
    HRESULT _hr = raw_GetTopLeft(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointPtr(_result, false);
}

inline ILPointPtr ILRect::GetTopRight ( ) {
    struct ILPoint * _result = 0;
    HRESULT _hr = raw_GetTopRight(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointPtr(_result, false);
}

inline ILPointPtr ILRect::GetBottomLeft ( ) {
    struct ILPoint * _result = 0;
    HRESULT _hr = raw_GetBottomLeft(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointPtr(_result, false);
}

inline ILPointPtr ILRect::GetBottomRight ( ) {
    struct ILPoint * _result = 0;
    HRESULT _hr = raw_GetBottomRight(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointPtr(_result, false);
}

inline ILPointsPtr ILRect::GetPoints ( ) {
    struct ILPoints * _result = 0;
    HRESULT _hr = raw_GetPoints(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointsPtr(_result, false);
}

inline enum LPVPointTestResult ILRect::PointTest ( struct ILPoint * point ) {
    enum LPVPointTestResult _result;
    HRESULT _hr = raw_PointTest(point, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

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

inline ILRectPtr ILRect::Transform ( struct ILTransform * tf ) {
    struct ILRect * _result = 0;
    HRESULT _hr = raw_Transform(tf, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILRectPtr(_result, false);
}

inline ILRotRectRegionPtr ILRect::ToRotRectRegion ( ) {
    struct ILRotRectRegion * _result = 0;
    HRESULT _hr = raw_ToRotRectRegion(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILRotRectRegionPtr(_result, false);
}

inline HRESULT ILRect::FromRotRectRegion ( struct ILRotRectRegion * val ) {
    HRESULT _hr = raw_FromRotRectRegion(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline ILRectRegionPtr ILRect::ToRectRegion ( ) {
    struct ILRectRegion * _result = 0;
    HRESULT _hr = raw_ToRectRegion(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILRectRegionPtr(_result, false);
}

inline HRESULT ILRect::FromRectRegion ( struct ILRectRegion * val ) {
    HRESULT _hr = raw_FromRectRegion(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline double ILRect::GetPerimeter ( ) {
    double _result = 0;
    HRESULT _hr = raw_GetPerimeter(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILRect::GetArea ( ) {
    double _result = 0;
    HRESULT _hr = raw_GetArea(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline ILRectPtr ILRect::GetBoundingRect ( ) {
    struct ILRect * _result = 0;
    HRESULT _hr = raw_GetBoundingRect(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILRectPtr(_result, false);
}

inline ILLinePtr ILRect::GetTop ( ) {
    struct ILLine * _result = 0;
    HRESULT _hr = raw_GetTop(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILLinePtr(_result, false);
}

inline ILLinePtr ILRect::GetBottom ( ) {
    struct ILLine * _result = 0;
    HRESULT _hr = raw_GetBottom(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILLinePtr(_result, false);
}

inline ILLinePtr ILRect::GetLeft ( ) {
    struct ILLine * _result = 0;
    HRESULT _hr = raw_GetLeft(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILLinePtr(_result, false);
}

inline ILLinePtr ILRect::GetRight ( ) {
    struct ILLine * _result = 0;
    HRESULT _hr = raw_GetRight(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILLinePtr(_result, false);
}

inline ILPolygonPtr ILRect::Resample ( int num ) {
    struct ILPolygon * _result = 0;
    HRESULT _hr = raw_Resample(num, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPolygonPtr(_result, false);
}

inline ILPolygonPtr ILRect::ResampleByStep ( double step, double stepThreshold ) {
    struct ILPolygon * _result = 0;
    HRESULT _hr = raw_ResampleByStep(step, stepThreshold, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPolygonPtr(_result, false);
}

//
// interface ILPolygon wrapper method implementations
//

inline VARIANT_BOOL ILPolygon::Valid ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_Valid(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

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

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

inline ILPointPtr ILPolygon::Item ( int index ) {
    struct ILPoint * _result = 0;
    HRESULT _hr = raw_Item(index, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointPtr(_result, false);
}

inline HRESULT ILPolygon::Set ( int index, double X, double Y ) {
    HRESULT _hr = raw_Set(index, X, Y);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

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

inline HRESULT ILPolygon::SetPolygon ( SAFEARRAY * xs, SAFEARRAY * ys, VARIANT_BOOL isClosed ) {
    HRESULT _hr = raw_SetPolygon(xs, ys, isClosed);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILPolygon::AddPoints ( struct ILPoints * points ) {
    HRESULT _hr = raw_AddPoints(points);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILPolygon::RemovePoints ( double lbX, double ubX, double lbY, double ubY ) {
    HRESULT _hr = raw_RemovePoints(lbX, ubX, lbY, ubY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline ILPointsPtr ILPolygon::GetPoints ( ) {
    struct ILPoints * _result = 0;
    HRESULT _hr = raw_GetPoints(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointsPtr(_result, false);
}

inline VARIANT_BOOL ILPolygon::GetClosed ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_Closed(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILPolygon::PutClosed ( VARIANT_BOOL val ) {
    HRESULT _hr = put_Closed(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline enum LPVPointTestResult ILPolygon::PointTest ( struct ILPoint * point ) {
    enum LPVPointTestResult _result;
    HRESULT _hr = raw_PointTest(point, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline enum LPVIntersectType ILPolygon::IntersectLine ( struct ILLine * line, struct ILPoints * * intersectPoints ) {
    enum LPVIntersectType _result;
    HRESULT _hr = raw_IntersectLine(line, intersectPoints, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline ILCirclePtr ILPolygon::GetInscribedCircle ( ) {
    struct ILCircle * _result = 0;
    HRESULT _hr = raw_GetInscribedCircle(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILCirclePtr(_result, false);
}

inline ILPointPtr ILPolygon::GetGravityCenter ( ) {
    struct ILPoint * _result = 0;
    HRESULT _hr = raw_GetGravityCenter(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointPtr(_result, false);
}

inline double ILPolygon::DistanceToPoint ( struct ILPoint * point, enum LPVAggregation aggType, struct ILPoint * * rootPoint ) {
    double _result = 0;
    HRESULT _hr = raw_DistanceToPoint(point, aggType, rootPoint, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILPolygon::DistanceToPolygon ( struct ILPolygon * polygon, enum LPVAggregation aggType, struct ILPoint * * rootPoint1, struct ILPoint * * rootPoint2 ) {
    double _result = 0;
    HRESULT _hr = raw_DistanceToPolygon(polygon, aggType, rootPoint1, rootPoint2, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

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

inline ILPolygonPtr ILPolygon::Transform ( struct ILTransform * tf ) {
    struct ILPolygon * _result = 0;
    HRESULT _hr = raw_Transform(tf, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPolygonPtr(_result, false);
}

inline ILPolyRegionPtr ILPolygon::ToPolyRegion ( ) {
    struct ILPolyRegion * _result = 0;
    HRESULT _hr = raw_ToPolyRegion(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPolyRegionPtr(_result, false);
}

inline HRESULT ILPolygon::FromPolyRegion ( struct ILPolyRegion * val ) {
    HRESULT _hr = raw_FromPolyRegion(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline double ILPolygon::GetPerimeter ( ) {
    double _result = 0;
    HRESULT _hr = raw_GetPerimeter(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILPolygon::GetArea ( ) {
    double _result = 0;
    HRESULT _hr = raw_GetArea(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline ILPolygonPtr ILPolygon::Resample ( int num ) {
    struct ILPolygon * _result = 0;
    HRESULT _hr = raw_Resample(num, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPolygonPtr(_result, false);
}

inline ILPolygonPtr ILPolygon::ResampleByStep ( double step, double stepThreshold ) {
    struct ILPolygon * _result = 0;
    HRESULT _hr = raw_ResampleByStep(step, stepThreshold, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPolygonPtr(_result, false);
}

inline VARIANT_BOOL ILPolygon::IntersectPolygon ( struct ILPolygon * polygon, struct ILPoints * * intersectPoints ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_IntersectPolygon(polygon, intersectPoints, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

//
// interface ILEllipse wrapper method implementations
//

inline double ILEllipse::GetX ( ) {
    double _result = 0;
    HRESULT _hr = get_X(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILEllipse::PutX ( double val ) {
    HRESULT _hr = put_X(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILEllipse::GetY ( ) {
    double _result = 0;
    HRESULT _hr = get_Y(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILEllipse::PutY ( double val ) {
    HRESULT _hr = put_Y(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

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

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

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

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

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

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

inline VARIANT_BOOL ILEllipse::Valid ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_Valid(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILEllipse::Set ( double X, double Y, double w, double h, double a ) {
    HRESULT _hr = raw_Set(X, Y, w, h, a);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

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

inline ILPointPtr ILEllipse::GetCenter ( ) {
    struct ILPoint * _result = 0;
    HRESULT _hr = raw_GetCenter(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointPtr(_result, false);
}

inline ILPointPtr ILEllipse::GetTop ( ) {
    struct ILPoint * _result = 0;
    HRESULT _hr = raw_GetTop(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointPtr(_result, false);
}

inline ILPointPtr ILEllipse::GetBottom ( ) {
    struct ILPoint * _result = 0;
    HRESULT _hr = raw_GetBottom(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointPtr(_result, false);
}

inline ILPointPtr ILEllipse::GetLeft ( ) {
    struct ILPoint * _result = 0;
    HRESULT _hr = raw_GetLeft(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointPtr(_result, false);
}

inline ILPointPtr ILEllipse::GetRight ( ) {
    struct ILPoint * _result = 0;
    HRESULT _hr = raw_GetRight(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointPtr(_result, false);
}

inline ILRectPtr ILEllipse::GetBoundingRect ( ) {
    struct ILRect * _result = 0;
    HRESULT _hr = raw_GetBoundingRect(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILRectPtr(_result, false);
}

inline ILRectPtr ILEllipse::GetBoundingRotRect ( ) {
    struct ILRect * _result = 0;
    HRESULT _hr = raw_GetBoundingRotRect(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILRectPtr(_result, false);
}

inline ILPolygonPtr ILEllipse::SamplingByAngle ( double startArcAngle, double endArcAngle, double stepAngle ) {
    struct ILPolygon * _result = 0;
    HRESULT _hr = raw_SamplingByAngle(startArcAngle, endArcAngle, stepAngle, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPolygonPtr(_result, false);
}

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

inline ILEllipsePtr ILEllipse::Transform ( struct ILTransform * tf ) {
    struct ILEllipse * _result = 0;
    HRESULT _hr = raw_Transform(tf, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILEllipsePtr(_result, false);
}

inline ILEllipseRegionPtr ILEllipse::ToEllipseRegion ( ) {
    struct ILEllipseRegion * _result = 0;
    HRESULT _hr = raw_ToEllipseRegion(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILEllipseRegionPtr(_result, false);
}

inline HRESULT ILEllipse::FromEllipseRegion ( struct ILEllipseRegion * val ) {
    HRESULT _hr = raw_FromEllipseRegion(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline double ILEllipse::GetPerimeter ( ) {
    double _result = 0;
    HRESULT _hr = raw_GetPerimeter(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILEllipse::GetArea ( ) {
    double _result = 0;
    HRESULT _hr = raw_GetArea(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline ILPolygonPtr ILEllipse::Resample ( int num ) {
    struct ILPolygon * _result = 0;
    HRESULT _hr = raw_Resample(num, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPolygonPtr(_result, false);
}

//
// interface ILCircle wrapper method implementations
//

inline double ILCircle::GetX ( ) {
    double _result = 0;
    HRESULT _hr = get_X(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCircle::PutX ( double val ) {
    HRESULT _hr = put_X(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILCircle::GetY ( ) {
    double _result = 0;
    HRESULT _hr = get_Y(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCircle::PutY ( double val ) {
    HRESULT _hr = put_Y(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

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

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

inline VARIANT_BOOL ILCircle::Valid ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_Valid(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILCircle::Set ( double X, double Y, double r ) {
    HRESULT _hr = raw_Set(X, Y, r);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

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

inline ILPointPtr ILCircle::GetCenter ( ) {
    struct ILPoint * _result = 0;
    HRESULT _hr = raw_GetCenter(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointPtr(_result, false);
}

inline ILArcPtr ILCircle::GetArc ( double aStart, double aEnd ) {
    struct ILArc * _result = 0;
    HRESULT _hr = raw_GetArc(aStart, aEnd, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILArcPtr(_result, false);
}

inline enum LPVPointTestResult ILCircle::PointTest ( struct ILPoint * point ) {
    enum LPVPointTestResult _result;
    HRESULT _hr = raw_PointTest(point, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILCircle::Concentric ( struct ILCircle * circle ) {
    double _result = 0;
    HRESULT _hr = raw_Concentric(circle, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline enum LPVIntersectType ILCircle::IntersectLine ( struct ILLine * line, struct ILPoints * * intersectPoints ) {
    enum LPVIntersectType _result;
    HRESULT _hr = raw_IntersectLine(line, intersectPoints, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

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

inline ILCirclePtr ILCircle::Transform ( struct ILTransform * tf ) {
    struct ILCircle * _result = 0;
    HRESULT _hr = raw_Transform(tf, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILCirclePtr(_result, false);
}

inline ILCircleRegionPtr ILCircle::ToCircleRegion ( ) {
    struct ILCircleRegion * _result = 0;
    HRESULT _hr = raw_ToCircleRegion(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILCircleRegionPtr(_result, false);
}

inline ILAnnulusRegionPtr ILCircle::ToAnnulusRegion ( int inExp, int outExp ) {
    struct ILAnnulusRegion * _result = 0;
    HRESULT _hr = raw_ToAnnulusRegion(inExp, outExp, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILAnnulusRegionPtr(_result, false);
}

inline HRESULT ILCircle::FromCircleRegion ( struct ILCircleRegion * val ) {
    HRESULT _hr = raw_FromCircleRegion(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILCircle::FromAnnulusRegion ( struct ILAnnulusRegion * val ) {
    HRESULT _hr = raw_FromAnnulusRegion(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline double ILCircle::GetPerimeter ( ) {
    double _result = 0;
    HRESULT _hr = raw_GetPerimeter(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILCircle::GetArea ( ) {
    double _result = 0;
    HRESULT _hr = raw_GetArea(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline ILPolygonPtr ILCircle::Resample ( int num ) {
    struct ILPolygon * _result = 0;
    HRESULT _hr = raw_Resample(num, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPolygonPtr(_result, false);
}

//
// interface ILArc wrapper method implementations
//

inline double ILArc::GetX ( ) {
    double _result = 0;
    HRESULT _hr = get_X(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILArc::PutX ( double val ) {
    HRESULT _hr = put_X(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILArc::GetY ( ) {
    double _result = 0;
    HRESULT _hr = get_Y(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILArc::PutY ( double val ) {
    HRESULT _hr = put_Y(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

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

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

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

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

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

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

inline VARIANT_BOOL ILArc::Valid ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_Valid(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILArc::Set ( double X, double Y, double r, double aStart, double aEnd ) {
    HRESULT _hr = raw_Set(X, Y, r, aStart, aEnd);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

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

inline ILPointPtr ILArc::GetCenter ( ) {
    struct ILPoint * _result = 0;
    HRESULT _hr = raw_GetCenter(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointPtr(_result, false);
}

inline ILCirclePtr ILArc::GetCircle ( ) {
    struct ILCircle * _result = 0;
    HRESULT _hr = raw_GetCircle(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILCirclePtr(_result, false);
}

inline ILPointPtr ILArc::GetStartPoint ( ) {
    struct ILPoint * _result = 0;
    HRESULT _hr = raw_GetStartPoint(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointPtr(_result, false);
}

inline ILPointPtr ILArc::GetEndPoint ( ) {
    struct ILPoint * _result = 0;
    HRESULT _hr = raw_GetEndPoint(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointPtr(_result, false);
}

inline ILRectPtr ILArc::GetBoundingRect ( ) {
    struct ILRect * _result = 0;
    HRESULT _hr = raw_GetBoundingRect(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILRectPtr(_result, false);
}

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

inline ILArcPtr ILArc::Transform ( struct ILTransform * tf ) {
    struct ILArc * _result = 0;
    HRESULT _hr = raw_Transform(tf, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILArcPtr(_result, false);
}

inline ILAnnulusSectorRegionPtr ILArc::ToAnnulusSectorRegion ( int inExp, int outExp ) {
    struct ILAnnulusSectorRegion * _result = 0;
    HRESULT _hr = raw_ToAnnulusSectorRegion(inExp, outExp, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILAnnulusSectorRegionPtr(_result, false);
}

inline HRESULT ILArc::FromAnnulusSectorRegion ( struct ILAnnulusSectorRegion * val ) {
    HRESULT _hr = raw_FromAnnulusSectorRegion(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline double ILArc::GetLength ( ) {
    double _result = 0;
    HRESULT _hr = raw_GetLength(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

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

inline ILPolygonPtr ILArc::Resample ( int num ) {
    struct ILPolygon * _result = 0;
    HRESULT _hr = raw_Resample(num, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPolygonPtr(_result, false);
}