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

// Created by Microsoft (R) C/C++ Compiler Version 14.16.27051.0 (739a92f1).
//
// d:\code\logistics\smokeboxidentification\tpvs17\smokeboxidentification\x64\release\lpvGeomX.tli
//
// Wrapper implementations for Win32 type library 02517f91-b197-4cd5-a1b5-92d1da6ca9ce
// compiler-generated file created 01/03/24 at 16:59:27 - DO NOT EDIT!

#pragma once

//
// interface ILSortedArray wrapper method implementations
//

inline int ILSortedArray::GetRowCount ( ) {
    int _result = 0;
    HRESULT _hr = get_RowCount(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline int ILSortedArray::GetColumnCount ( ) {
    int _result = 0;
    HRESULT _hr = get_ColumnCount(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline VARIANT_BOOL ILSortedArray::GetHasItem ( int columnIndex, int rowIndex ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_HasItem(columnIndex, rowIndex, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline ILSortablePtr ILSortedArray::GetItem ( int columnIndex, int rowIndex ) {
    struct ILSortable * _result = 0;
    HRESULT _hr = get_Item(columnIndex, rowIndex, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILSortablePtr(_result, false);
}

inline ILPointPtr ILSortedArray::GetPosition ( int columnIndex, int rowIndex ) {
    struct ILPoint * _result = 0;
    HRESULT _hr = get_Position(columnIndex, rowIndex, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointPtr(_result, false);
}

inline ILLinePtr ILSortedArray::GetRowLine ( int rowIndex ) {
    struct ILLine * _result = 0;
    HRESULT _hr = get_RowLine(rowIndex, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILLinePtr(_result, false);
}

inline ILLinePtr ILSortedArray::GetColumnLine ( int columnIndex ) {
    struct ILLine * _result = 0;
    HRESULT _hr = get_ColumnLine(columnIndex, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILLinePtr(_result, false);
}

inline double ILSortedArray::GetAvgRowSpace ( ) {
    double _result = 0;
    HRESULT _hr = get_AvgRowSpace(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILSortedArray::GetAvgColumnSpace ( ) {
    double _result = 0;
    HRESULT _hr = get_AvgColumnSpace(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

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

inline int ILSortedArray::GetFilteredCount ( ) {
    int _result = 0;
    HRESULT _hr = get_FilteredCount(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline ILSortablePtr ILSortedArray::GetItemFiltered ( int index ) {
    struct ILSortable * _result = 0;
    HRESULT _hr = get_ItemFiltered(index, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILSortablePtr(_result, false);
}

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

//
// interface ILGeomOp wrapper method implementations
//

inline ILRectPtr ILGeomOp::InnerRect ( struct ILImage * mask ) {
    struct ILRect * _result = 0;
    HRESULT _hr = raw_InnerRect(mask, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILRectPtr(_result, false);
}

inline ILRectPtr ILGeomOp::InnerSquare ( struct ILImage * mask ) {
    struct ILRect * _result = 0;
    HRESULT _hr = raw_InnerSquare(mask, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILRectPtr(_result, false);
}

//
// interface ILSorter wrapper method implementations
//

inline HRESULT ILSorter::SetSource ( struct ILSortables * sortables ) {
    HRESULT _hr = raw_SetSource(sortables);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILSorter::SetSource2 ( SAFEARRAY * sortableArray ) {
    HRESULT _hr = raw_SetSource2(sortableArray);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline enum LPVErrorCode ILSorter::SortToArray ( enum LPVPositionMode posMode, double columnSpaceAppr, double rowSpaceAppr, double toleranceFactor, struct ILSortedArray * * sortedResult ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_SortToArray(posMode, columnSpaceAppr, rowSpaceAppr, toleranceFactor, sortedResult, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

//
// interface ILPolygonClipper wrapper method implementations
//

inline ILPolygonPtr ILPolygonClipper::Smooth ( struct ILPolygon * poly, double nbRange ) {
    struct ILPolygon * _result = 0;
    HRESULT _hr = raw_Smooth(poly, nbRange, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPolygonPtr(_result, false);
}

inline ILPolygonPtr ILPolygonClipper::SmoothIterative ( struct ILPolygon * poly, double filterNbRng, double updateNbRng, int maxIterCount, double stopCriteria ) {
    struct ILPolygon * _result = 0;
    HRESULT _hr = raw_SmoothIterative(poly, filterNbRng, updateNbRng, maxIterCount, stopCriteria, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPolygonPtr(_result, false);
}

inline ILPolygonPtr ILPolygonClipper::Simplify ( struct ILPolygon * poly, int maxVertexes, double areaThreshold, double angleThreshold ) {
    struct ILPolygon * _result = 0;
    HRESULT _hr = raw_Simplify(poly, maxVertexes, areaThreshold, angleThreshold, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPolygonPtr(_result, false);
}

inline ILPolygonPtr ILPolygonClipper::SimplifyDP ( struct ILPolygon * poly, double distThreshold ) {
    struct ILPolygon * _result = 0;
    HRESULT _hr = raw_SimplifyDP(poly, distThreshold, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPolygonPtr(_result, false);
}

inline ILPolygonPtr ILPolygonClipper::TrimCollinear ( struct ILPolygon * poly ) {
    struct ILPolygon * _result = 0;
    HRESULT _hr = raw_TrimCollinear(poly, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPolygonPtr(_result, false);
}

inline ILPolygonPtr ILPolygonClipper::Expand ( struct ILPolygon * poly, double delta, double miterLimit ) {
    struct ILPolygon * _result = 0;
    HRESULT _hr = raw_Expand(poly, delta, miterLimit, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPolygonPtr(_result, false);
}

inline ILPolygonPtr ILPolygonClipper::Shrink ( struct ILPolygon * poly, double delta, double miterLimit ) {
    struct ILPolygon * _result = 0;
    HRESULT _hr = raw_Shrink(poly, delta, miterLimit, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPolygonPtr(_result, false);
}

inline SAFEARRAY * ILPolygonClipper::Union ( struct ILPolygon * poly1, struct ILPolygon * poly2 ) {
    SAFEARRAY * _result = 0;
    HRESULT _hr = raw_Union(poly1, poly2, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline ILPolygonPtr ILPolygonClipper::Union1 ( struct ILPolygon * poly1, struct ILPolygon * poly2 ) {
    struct ILPolygon * _result = 0;
    HRESULT _hr = raw_Union1(poly1, poly2, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPolygonPtr(_result, false);
}

inline SAFEARRAY * ILPolygonClipper::Subtract ( struct ILPolygon * poly1, struct ILPolygon * poly2 ) {
    SAFEARRAY * _result = 0;
    HRESULT _hr = raw_Subtract(poly1, poly2, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline ILPolygonPtr ILPolygonClipper::Subtract1 ( struct ILPolygon * poly1, struct ILPolygon * poly2 ) {
    struct ILPolygon * _result = 0;
    HRESULT _hr = raw_Subtract1(poly1, poly2, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPolygonPtr(_result, false);
}

inline SAFEARRAY * ILPolygonClipper::Intersect ( struct ILPolygon * poly1, struct ILPolygon * poly2 ) {
    SAFEARRAY * _result = 0;
    HRESULT _hr = raw_Intersect(poly1, poly2, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline ILPolygonPtr ILPolygonClipper::Intersect1 ( struct ILPolygon * poly1, struct ILPolygon * poly2 ) {
    struct ILPolygon * _result = 0;
    HRESULT _hr = raw_Intersect1(poly1, poly2, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPolygonPtr(_result, false);
}

inline SAFEARRAY * ILPolygonClipper::XOR ( struct ILPolygon * poly1, struct ILPolygon * poly2 ) {
    SAFEARRAY * _result = 0;
    HRESULT _hr = raw_XOR(poly1, poly2, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}