ole.c

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C语言 代码 · 共 1,211 行 · 第 1/3 页

    rc = olecliOleCreateLinkFromClip( protocol, lpclient, cdoc, objname,
                        lplpobj, renderopts, cfmt );

    return( rc );

} /* __OleCreateLinkFromClip */

/*
 * __OleCreateLinkFromFile - cover function for olecli function OleCreateLinkFromFile
 */
OLESTATUS FAR PASCAL __OleCreateLinkFromFile(LPCSTR protocol, LPOLECLIENT lpclient,
                        LPCSTR class, LPCSTR file, LPCSTR item, LHCLIENTDOC cdoc,
                        LPCSTR objname, LPOLEOBJECT FAR*lplpobj,
                        OLEOPT_RENDER renderopts, OLECLIPFORMAT cfmt)
{
    OLESTATUS           rc;

    if( olecliOleCreateLinkFromFile == NULL ) {
        olecliOleCreateLinkFromFile = Backpatch_olecli( "OleCreateLinkFromFile" );
        if( olecliOleCreateLinkFromFile == NULL ) return( 0 );
    }

    permAliasOleClient( &lpclient );
    rc = olecliOleCreateLinkFromFile( protocol, lpclient, class, file, item,
                        cdoc, objname, lplpobj, renderopts, cfmt );

    return( rc );

} /* __OleCreateLinkFromFile */

/*
 * __OleDelete - cover function for olecli function OleDelete
 */
OLESTATUS FAR PASCAL __OleDelete(LPOLEOBJECT lpobject )
{
    OLESTATUS           rc;
    LPOLEOBJECTVTBL     olpvtbl;

    if( olecliOleDelete == NULL ) {
        olecliOleDelete = Backpatch_olecli( "OleDelete" );
        if( olecliOleDelete == NULL ) return( 0 );
    }

    aliasOleObject( lpobject, &olpvtbl );
    rc = olecliOleDelete( lpobject );
    releaseAliasOleObject( lpobject, olpvtbl );

    return( rc );

} /* __OleDelete */

/*
 * __OleDraw - cover function for olecli function OleDraw
 */
OLESTATUS FAR PASCAL __OleDraw( LPOLEOBJECT lpobject, HDC hdc,
                                const RECT FAR* bounds, const RECT FAR*wbounds,
                                HDC hdcformat )
{
    OLESTATUS           rc;
    LPOLEOBJECTVTBL     olpvtbl;

    if( olecliOleDraw == NULL ) {
        olecliOleDraw = Backpatch_olecli( "OleDraw" );
        if( olecliOleDraw == NULL ) return( 0 );
    }

    aliasOleObject( lpobject, &olpvtbl );
    rc = olecliOleDraw( lpobject, hdc, bounds, wbounds, hdcformat );
    releaseAliasOleObject( lpobject, olpvtbl );

    return( rc );

} /* __OleDraw */

/*
 * __OleEnumFormats - cover function for olecli function OleEnumFormats
 */
OLECLIPFORMAT FAR PASCAL __OleEnumFormats(LPOLEOBJECT lpobject,
                                                OLECLIPFORMAT cfmt )
{
    OLECLIPFORMAT       rc;
    LPOLEOBJECTVTBL     olpvtbl;

    if( olecliOleEnumFormats == NULL ) {
        olecliOleEnumFormats = Backpatch_olecli( "OleEnumFormats" );
        if( olecliOleEnumFormats == NULL ) return( 0 );
    }

    aliasOleObject( lpobject, &olpvtbl );
    rc = olecliOleEnumFormats( lpobject, cfmt );
    releaseAliasOleObject( lpobject, olpvtbl );

    return( rc );

} /* __OleEnumFormats */

/*
 * __OleEqual - cover function for olecli function OleEqual
 */
OLESTATUS FAR PASCAL __OleEqual( LPOLEOBJECT lpobject1, LPOLEOBJECT lpobject2 )
{
    OLESTATUS           rc;
    LPOLEOBJECTVTBL     olpvtbl1,olpvtbl2;

    if( olecliOleEqual == NULL ) {
        olecliOleEqual = Backpatch_olecli( "OleEqual" );
        if( olecliOleEqual == NULL ) return( 0 );
    }

    aliasOleObject( lpobject1, &olpvtbl1 );
    aliasOleObject( lpobject2, &olpvtbl2 );
    rc = olecliOleEqual( lpobject1, lpobject2 );
    releaseAliasOleObject( lpobject1, olpvtbl1 );
    releaseAliasOleObject( lpobject2, olpvtbl2 );

    return( rc );

} /* __OleEqual */

/*
 * __OleExecute - cover function for olecli function OleExecute
 */
OLESTATUS FAR PASCAL __OleExecute( LPOLEOBJECT lpobject, HGLOBAL cmds, UINT r )
{
    OLESTATUS           rc;
    LPOLEOBJECTVTBL     olpvtbl;

    if( olecliOleExecute == NULL ) {
        olecliOleExecute = Backpatch_olecli( "OleExecute" );
        if( olecliOleExecute == NULL ) return( 0 );
    }

    aliasOleObject( lpobject, &olpvtbl );
    rc = olecliOleExecute( lpobject, cmds, r );
    releaseAliasOleObject( lpobject, olpvtbl );

    return( rc );

} /* __OleExecute */

/*
 * __OleGetData - cover function for olecli function OleGetData
 */
OLESTATUS FAR PASCAL __OleGetData( LPOLEOBJECT lpobject, OLECLIPFORMAT cfmt,
                        HANDLE FAR*res )
{
    OLESTATUS           rc;
    LPOLEOBJECTVTBL     olpvtbl;

    if( olecliOleGetData == NULL ) {
        olecliOleGetData = Backpatch_olecli( "OleGetData" );
        if( olecliOleGetData == NULL ) return( 0 );
    }

    aliasOleObject( lpobject, &olpvtbl );
    rc = olecliOleGetData( lpobject, cfmt, res );
    releaseAliasOleObject( lpobject, olpvtbl );

    return( rc );

} /* __OleGetData */

/*
 * __OleGetLinkUpdateOptions - cover function for olecli function OleGetLinkUpdateOptions
 */
OLESTATUS FAR PASCAL __OleGetLinkUpdateOptions( LPOLEOBJECT lpobject,
                                OLEOPT_UPDATE FAR*updateopt)
{
    OLESTATUS           rc;
    LPOLEOBJECTVTBL     olpvtbl;

    if( olecliOleGetLinkUpdateOptions == NULL ) {
        olecliOleGetLinkUpdateOptions = Backpatch_olecli( "OleGetLinkUpdateOptions" );
        if( olecliOleGetLinkUpdateOptions == NULL ) return( 0 );
    }

    aliasOleObject( lpobject, &olpvtbl );
    rc = olecliOleGetLinkUpdateOptions( lpobject, updateopt );
    releaseAliasOleObject( lpobject, olpvtbl );

    return( rc );

} /* __OleGetLinkUpdateOptions */

/*
 * __OleLoadFromStream - cover function for olecli function OleLoadFromStream
 */
OLESTATUS FAR PASCAL __OleLoadFromStream( LPOLESTREAM lpstream, LPCSTR protocol,
                LPOLECLIENT lpclient, LHCLIENTDOC cdoc, LPCSTR objname,
                LPOLEOBJECT FAR* lplpobj )
{
    OLESTATUS           rc;
    LPOLECLIENTVTBL     olpvtblc;
    LPOLESTREAMVTBL     olpstbl;

    if( olecliOleLoadFromStream == NULL ) {
        olecliOleLoadFromStream = Backpatch_olecli( "OleLoadFromStream" );
        if( olecliOleLoadFromStream == NULL ) return( 0 );
    }

    aliasOleClient( lpclient, &olpvtblc );
    aliasOleStream( lpstream, &olpstbl );
    rc = olecliOleLoadFromStream( lpstream, protocol, lpclient, cdoc, objname,
                                        lplpobj );
    releaseAliasOleClient( lpclient, olpvtblc );
    releaseAliasOleStream( lpstream, olpstbl );

    return( rc );

} /* __OleLoadFromStream */

/*
 * __OleLockServer - cover function for olecli function OleLockServer
 */
OLESTATUS FAR PASCAL __OleLockServer( LPOLEOBJECT lpobject, LHSERVER FAR* hsrv)
{
    OLESTATUS           rc;
    LPOLEOBJECTVTBL     olpvtbl;

    if( olecliOleLockServer == NULL ) {
        olecliOleLockServer = Backpatch_olecli( "OleLockServer" );
        if( olecliOleLockServer == NULL ) return( 0 );
    }

    aliasOleObject( lpobject, &olpvtbl );
    rc = olecliOleLockServer( lpobject, hsrv );
    releaseAliasOleObject( lpobject, olpvtbl );

    return( rc );

} /* __OleLockServer */

/*
 * __OleObjectConvert - cover function for olecli function OleObjectConvert
 */
OLESTATUS FAR PASCAL __OleObjectConvert( LPOLEOBJECT lpobject, LPCSTR protocol,
                        LPOLECLIENT lpclient, LHCLIENTDOC cdoc, LPCSTR objname,
                        LPOLEOBJECT FAR* lplpobj )
{
    OLESTATUS           rc;
    LPOLEOBJECTVTBL     olpvtbl;
    LPOLECLIENTVTBL     olpvtblc;

    if( olecliOleObjectConvert == NULL ) {
        olecliOleObjectConvert = Backpatch_olecli( "OleObjectConvert" );
        if( olecliOleObjectConvert == NULL ) return( 0 );
    }

    aliasOleObject( lpobject, &olpvtbl );
    aliasOleClient( lpclient, &olpvtblc );
    rc = olecliOleObjectConvert( lpobject, protocol, lpclient, cdoc, objname, lplpobj );
    releaseAliasOleObject( lpobject, olpvtbl );
    releaseAliasOleClient( lpclient, olpvtblc );

    return( rc );

} /* __OleObjectConvert */

/*
 * __OleQueryBounds - cover function for olecli function OleQueryBounds
 */
OLESTATUS FAR PASCAL __OleQueryBounds( LPOLEOBJECT lpobject, RECT FAR* bounds)
{
    OLESTATUS           rc;
    LPOLEOBJECTVTBL     olpvtbl;

    if( olecliOleQueryBounds == NULL ) {
        olecliOleQueryBounds = Backpatch_olecli( "OleQueryBounds" );
        if( olecliOleQueryBounds == NULL ) return( 0 );
    }

    aliasOleObject( lpobject, &olpvtbl );
    rc = olecliOleQueryBounds( lpobject, bounds );
    releaseAliasOleObject( lpobject, olpvtbl );

    return( rc );

} /* __OleQueryBounds */

/*
 * __OleQueryName - cover function for olecli function OleQueryName
 */
OLESTATUS FAR PASCAL __OleQueryName(LPOLEOBJECT lpobject, LPSTR object,
                                UINT FAR*buffsize)
{
    OLESTATUS           rc;
    LPOLEOBJECTVTBL     olpvtbl;

    if( olecliOleQueryName == NULL ) {
        olecliOleQueryName = Backpatch_olecli( "OleQueryName" );
        if( olecliOleQueryName == NULL ) return( 0 );
    }

    aliasOleObject( lpobject, &olpvtbl );
    rc = olecliOleQueryName( lpobject, object, buffsize );
    releaseAliasOleObject( lpobject, olpvtbl );

    return( rc );

} /* __OleQueryName */

/*
 * __OleQueryOpen - cover function for olecli function OleQueryOpen
 */
OLESTATUS FAR PASCAL __OleQueryOpen( LPOLEOBJECT lpobject )
{
    OLESTATUS           rc;
    LPOLEOBJECTVTBL     olpvtbl;

    if( olecliOleQueryOpen == NULL ) {
        olecliOleQueryOpen = Backpatch_olecli( "OleQueryOpen" );
        if( olecliOleQueryOpen == NULL ) return( 0 );
    }

    aliasOleObject( lpobject, &olpvtbl );
    rc = olecliOleQueryOpen( lpobject );
    releaseAliasOleObject( lpobject, olpvtbl );

    return( rc );

} /* __OleQueryOpen */

/*
 * __OleQueryOutOfDate - cover function for olecli function OleQueryOutOfDate
 */
OLESTATUS FAR PASCAL __OleQueryOutOfDate( LPOLEOBJECT lpobject )
{
    OLESTATUS           rc;
    LPOLEOBJECTVTBL     olpvtbl;

    if( olecliOleQueryOutOfDate == NULL ) {
        olecliOleQueryOutOfDate = Backpatch_olecli( "OleQueryOutOfDate" );
        if( olecliOleQueryOutOfDate == NULL ) return( 0 );
    }

    aliasOleObject( lpobject, &olpvtbl );
    rc = olecliOleQueryOutOfDate( lpobject );
    releaseAliasOleObject( lpobject, olpvtbl );

    return( rc );

} /* __OleQueryOutOfDate */

/*
 * __OleQueryProtocol - cover function for olecli function OleQueryProtocol
 */
LPVOID FAR PASCAL __OleQueryProtocol( LPOLEOBJECT lpobject, LPCSTR protocol )
{
    LPVOID              rc;
    LPOLEOBJECTVTBL     olpvtbl;

    if( olecliOleQueryProtocol == NULL ) {
        olecliOleQueryProtocol = Backpatch_olecli( "OleQueryProtocol" );
        if( olecliOleQueryProtocol == NULL ) return( 0 );
    }

    aliasOleObject( lpobject, &olpvtbl );
    rc = olecliOleQueryProtocol( lpobject, protocol );
    releaseAliasOleObject( lpobject, olpvtbl );

    return( rc );

} /* __OleQueryProtocol */

/*
 * __OleQueryReleaseError - cover function for olecli function OleQueryReleaseError
 */
OLESTATUS FAR PASCAL __OleQueryReleaseError( LPOLEOBJECT lpobject )
{
    OLESTATUS           rc;
    LPOLEOBJECTVTBL     olpvtbl;

    if( olecliOleQueryReleaseError == NULL ) {
        olecliOleQueryReleaseError = Backpatch_olecli( "OleQueryReleaseError" );
        if( olecliOleQueryReleaseError == NULL ) return( 0 );
    }

    aliasOleObject( lpobject, &olpvtbl );
    rc = olecliOleQueryReleaseError( lpobject );
    releaseAliasOleObject( lpobject, olpvtbl );

    return( rc );

} /* __OleQueryReleaseError */

/*
 * __OleQueryReleaseMethod - cover function for olecli function OleQueryReleaseMethod
 */
OLE_RELEASE_METHOD FAR PASCAL __OleQueryReleaseMethod( LPOLEOBJECT lpobject )
{
    OLE_RELEASE_METHOD  rc;
    LPOLEOBJECTVTBL     olpvtbl;

    if( olecliOleQueryReleaseMethod == NULL ) {
        olecliOleQueryReleaseMethod = Backpatch_olecli( "OleQueryReleaseMethod" );
        if( olecliOleQueryReleaseMethod == NULL ) return( 0 );
    }

    aliasOleObject( lpobject, &olpvtbl );
    rc = olecliOleQueryReleaseMethod( lpobject );
    releaseAliasOleObject( lpobject, olpvtbl );

    return( rc );