ole.c

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

/****************************************************************************
*
*                            Open Watcom Project
*
*    Portions Copyright (c) 1983-2002 Sybase, Inc. All Rights Reserved.
*
*  ========================================================================
*
*    This file contains Original Code and/or Modifications of Original
*    Code as defined in and that are subject to the Sybase Open Watcom
*    Public License version 1.0 (the 'License'). You may not use this file
*    except in compliance with the License. BY USING THIS FILE YOU AGREE TO
*    ALL TERMS AND CONDITIONS OF THE LICENSE. A copy of the License is
*    provided with the Original Code and Modifications, and is also
*    available at www.sybase.com/developer/opensource.
*
*    The Original Code and all software distributed under the License are
*    distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
*    EXPRESS OR IMPLIED, AND SYBASE AND ALL CONTRIBUTORS HEREBY DISCLAIM
*    ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF
*    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR
*    NON-INFRINGEMENT. Please see the License for the specific language
*    governing rights and limitations under the License.
*
*  ========================================================================
*
* Description:  Covers for OLE functions.
*
****************************************************************************/


#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <dos.h>
#include <windows.h>
#include <malloc.h>
#include <ole.h>
#include "winext.h"
#include "stubs.h"

#pragma aux Backpatch_olecli parm [ax];
extern LPVOID FAR Backpatch_olecli( char *str );

#pragma aux Backpatch_olesvr parm [ax];
extern LPVOID FAR Backpatch_olesvr( char *str );

static OLESTATUS (FAR PASCAL *olecliOleActivate)(LPOLEOBJECT, UINT, BOOL, BOOL, HWND, const RECT FAR*);
static OLESTATUS (FAR PASCAL *olecliOleClone)(LPOLEOBJECT, LPOLECLIENT, LHCLIENTDOC, LPCSTR, LPOLEOBJECT FAR*);
static OLESTATUS (FAR PASCAL *olecliOleClose)(LPOLEOBJECT);
static OLESTATUS (FAR PASCAL *olecliOleCopyFromLink)(LPOLEOBJECT, LPCSTR, LPOLECLIENT, LHCLIENTDOC, LPCSTR, LPOLEOBJECT FAR*);
static OLESTATUS (FAR PASCAL *olecliOleCopyToClipboard)(LPOLEOBJECT);
static OLESTATUS (FAR PASCAL *olecliOleCreate)(LPCSTR, LPOLECLIENT, LPCSTR, LHCLIENTDOC, LPCSTR, LPOLEOBJECT FAR*, OLEOPT_RENDER, OLECLIPFORMAT);
static OLESTATUS (FAR PASCAL *olecliOleCreateFromClip)(LPCSTR, LPOLECLIENT, LHCLIENTDOC, LPCSTR, LPOLEOBJECT FAR*, OLEOPT_RENDER, OLECLIPFORMAT);
static OLESTATUS (FAR PASCAL *olecliOleCreateFromFile)(LPCSTR, LPOLECLIENT, LPCSTR, LPCSTR, LHCLIENTDOC, LPCSTR, LPOLEOBJECT FAR*, OLEOPT_RENDER, OLECLIPFORMAT);
static OLESTATUS (FAR PASCAL *olecliOleCreateFromTemplate)(LPCSTR, LPOLECLIENT, LPCSTR, LHCLIENTDOC, LPCSTR, LPOLEOBJECT FAR*, OLEOPT_RENDER, OLECLIPFORMAT);
static OLESTATUS (FAR PASCAL *olecliOleCreateInvisible)(LPCSTR, LPOLECLIENT, LPCSTR, LHCLIENTDOC, LPCSTR, LPOLEOBJECT FAR*, OLEOPT_RENDER, OLECLIPFORMAT, BOOL);
static OLESTATUS (FAR PASCAL *olecliOleCreateLinkFromClip)(LPCSTR, LPOLECLIENT, LHCLIENTDOC, LPCSTR, LPOLEOBJECT FAR*, OLEOPT_RENDER, OLECLIPFORMAT);
static OLESTATUS (FAR PASCAL *olecliOleCreateLinkFromFile)(LPCSTR, LPOLECLIENT, LPCSTR, LPCSTR, LPCSTR, LHCLIENTDOC, LPCSTR, LPOLEOBJECT FAR*, OLEOPT_RENDER, OLECLIPFORMAT);
static OLESTATUS (FAR PASCAL *olecliOleDelete)(LPOLEOBJECT);
static OLESTATUS (FAR PASCAL *olecliOleDraw)(LPOLEOBJECT, HDC, const RECT FAR*, const RECT FAR*, HDC);
static OLECLIPFORMAT (FAR PASCAL *olecliOleEnumFormats)(LPOLEOBJECT, OLECLIPFORMAT);
static OLESTATUS (FAR PASCAL *olecliOleEqual)(LPOLEOBJECT, LPOLEOBJECT );
static OLESTATUS (FAR PASCAL *olecliOleExecute)(LPOLEOBJECT, HGLOBAL, UINT);
static OLESTATUS (FAR PASCAL *olecliOleGetData)(LPOLEOBJECT, OLECLIPFORMAT, HANDLE FAR*);
static OLESTATUS (FAR PASCAL *olecliOleGetLinkUpdateOptions)(LPOLEOBJECT, OLEOPT_UPDATE FAR*);
static OLESTATUS (FAR PASCAL *olecliOleLoadFromStream)(LPOLESTREAM, LPCSTR, LPOLECLIENT, LHCLIENTDOC, LPCSTR, LPOLEOBJECT FAR*);
static OLESTATUS (FAR PASCAL *olecliOleLockServer)(LPOLEOBJECT, LHSERVER FAR*);
static OLESTATUS (FAR PASCAL *olecliOleObjectConvert)(LPOLEOBJECT, LPCSTR, LPOLECLIENT, LHCLIENTDOC, LPCSTR, LPOLEOBJECT FAR*);
static OLESTATUS (FAR PASCAL *olecliOleQueryBounds)(LPOLEOBJECT, RECT FAR*);
static OLESTATUS (FAR PASCAL *olecliOleQueryName)(LPOLEOBJECT, LPSTR, UINT FAR*);
static OLESTATUS (FAR PASCAL *olecliOleQueryOpen)(LPOLEOBJECT);
static OLESTATUS (FAR PASCAL *olecliOleQueryOutOfDate)(LPOLEOBJECT);
static LPVOID (FAR PASCAL *olecliOleQueryProtocol)(LPOLEOBJECT, LPCSTR);
static OLESTATUS (FAR PASCAL *olecliOleQueryReleaseError)(LPOLEOBJECT);
static OLE_RELEASE_METHOD (FAR PASCAL *olecliOleQueryReleaseMethod)(LPOLEOBJECT);
static OLESTATUS (FAR PASCAL *olecliOleQueryReleaseStatus)(LPOLEOBJECT);
static OLESTATUS (FAR PASCAL *olecliOleQuerySize)(LPOLEOBJECT, DWORD FAR*);
static OLESTATUS (FAR PASCAL *olecliOleQueryType)(LPOLEOBJECT, LONG FAR*);
static OLESTATUS (FAR PASCAL *olecliOleReconnect)(LPOLEOBJECT);
static OLESTATUS (FAR PASCAL *olecliOleRelease)(LPOLEOBJECT);
static OLESTATUS (FAR PASCAL *olecliOleRename)(LPOLEOBJECT, LPCSTR);
static OLESTATUS (FAR PASCAL *olecliOleRequestData)(LPOLEOBJECT, OLECLIPFORMAT);
static OLESTATUS (FAR PASCAL *olecliOleSaveToStream)(LPOLEOBJECT, LPOLESTREAM);
static OLESTATUS (FAR PASCAL *olecliOleSetBounds)(LPOLEOBJECT, const RECT FAR*);
static OLESTATUS (FAR PASCAL *olecliOleSetColorScheme)(LPOLEOBJECT, const LOGPALETTE FAR*);
static OLESTATUS (FAR PASCAL *olecliOleSetData)(LPOLEOBJECT, OLECLIPFORMAT, HANDLE);
static OLESTATUS (FAR PASCAL *olecliOleSetHostNames)(LPOLEOBJECT, LPCSTR, LPCSTR);
static OLESTATUS (FAR PASCAL *olecliOleSetLinkUpdateOptions)(LPOLEOBJECT, OLEOPT_UPDATE);
static OLESTATUS (FAR PASCAL *olecliOleSetTargetDevice)(LPOLEOBJECT, HGLOBAL);
static OLESTATUS (FAR PASCAL *olecliOleUpdate)(LPOLEOBJECT);
static OLESTATUS (FAR PASCAL *olesvrOleRegisterServer)(LPCSTR, LPOLESERVER, LHSERVER FAR*, HINSTANCE, OLE_SERVER_USE);
static OLESTATUS (FAR PASCAL *olesvrOleRegisterServerDoc)(LHSERVER, LPCSTR, LPOLESERVERDOC, LHSERVERDOC FAR*);
static OLESTATUS (FAR PASCAL *olesvrOleRevokeObject)(LPOLECLIENT);


static void aliasOleObject( LPOLEOBJECT lpobject, LPOLEOBJECTVTBL _FAR *olpvtbl )
{
    LPOLEOBJECTVTBL     nlpvtbl;

    nlpvtbl = (*olpvtbl) = lpobject->lpvtbl;
    GetAlias( &nlpvtbl );
    lpobject->lpvtbl = nlpvtbl;

} /* aliasOleObject */

static void releaseAliasOleObject( LPOLEOBJECT lpobject, LPOLEOBJECTVTBL olpvtbl )
{
    ReleaseAlias( olpvtbl, lpobject->lpvtbl );
    lpobject->lpvtbl = olpvtbl;

} /* releaseAliasOleObject */

static void permAliasOleClient( LPOLECLIENT _FAR *lpclient )
{
    LPOLECLIENT         new;
    LPOLECLIENTVTBL     nlpvtbl;

    new = _fmalloc( sizeof( OLEOBJECT ) );
    new->lpvtbl = _fmalloc( sizeof( OLECLIENTVTBL ) );
    nlpvtbl = (*lpclient)->lpvtbl;
    GetAlias( &nlpvtbl );
    _fmemcpy( new->lpvtbl, nlpvtbl, sizeof( OLECLIENTVTBL ) );
    ReleaseAlias( (*lpclient)->lpvtbl, nlpvtbl );

    *lpclient = new;
}

static void aliasOleClient( LPOLECLIENT lpclient, LPOLECLIENTVTBL _FAR *olpvtbl )
{
    LPOLECLIENTVTBL     nlpvtbl;

    nlpvtbl = (*olpvtbl) = lpclient->lpvtbl;
    GetAlias( &nlpvtbl );
    lpclient->lpvtbl = nlpvtbl;

} /* aliasOleClient */

static void releaseAliasOleClient( LPOLECLIENT lpclient, LPOLECLIENTVTBL olpvtbl )
{
    ReleaseAlias( olpvtbl, lpclient->lpvtbl );
    lpclient->lpvtbl = olpvtbl;

} /* releaseAliasOleClient */

static void aliasOleStream( LPOLESTREAM lpstream, LPOLESTREAMVTBL _FAR *olpstbl )
{
    LPOLESTREAMVTBL     nlpstbl;

    nlpstbl = (*olpstbl) = lpstream->lpstbl;
    GetAlias( &nlpstbl );
    lpstream->lpstbl = nlpstbl;

} /* aliasOleStream */

static void releaseAliasOleStream( LPOLESTREAM lpstream, LPOLESTREAMVTBL olpstbl )
{
    ReleaseAlias( olpstbl, lpstream->lpstbl );
    lpstream->lpstbl = olpstbl;

} /* releaseAliasOleStream */

/*
 * __OleActivate - cover function for olecli function OleActivate
 */
OLESTATUS FAR PASCAL __OleActivate(LPOLEOBJECT lpobject, UINT verb, BOOL show,
                BOOL takefocus, HWND hwnd, const LPRECT bound )
{
    OLESTATUS           rc;
    LPOLEOBJECTVTBL     olpvtbl;

    if( olecliOleActivate == NULL ) {
        olecliOleActivate = Backpatch_olecli( "OleActivate" );
        if( olecliOleActivate == NULL ) return( 0 );
    }
    aliasOleObject( lpobject, &olpvtbl );
    rc = olecliOleActivate( lpobject, verb, show, takefocus, hwnd, bound );
    releaseAliasOleObject( lpobject, olpvtbl );

    return( rc );

} /* __OleActivate */

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

    if( olecliOleClone == NULL ) {
        olecliOleClone = Backpatch_olecli( "OleClone" );
        if( olecliOleClone == NULL ) return( 0 );
    }
    aliasOleObject( lpobject, &olpvtbl );
    aliasOleClient( lpclient, &olpvtblc );

    rc = olecliOleClone( lpobject, lpclient, cdoc, objname, lplpobj );

    releaseAliasOleObject( lpobject, olpvtbl );
    releaseAliasOleClient( lpclient, olpvtblc );

    return( rc );

} /* __OleClone */

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

    if( olecliOleClose == NULL ) {
        olecliOleClose = Backpatch_olecli( "OleClose" );
        if( olecliOleClose == NULL ) return( 0 );
    }
    aliasOleObject( lpobject, &olpvtbl );
    rc = olecliOleClose( lpobject );
    releaseAliasOleObject( lpobject, olpvtbl );

    return( rc );

} /* __OleClose */

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

    if( olecliOleCopyFromLink == NULL ) {
        olecliOleCopyFromLink = Backpatch_olecli( "OleCopyFromLink" );
        if( olecliOleCopyFromLink == NULL ) return( 0 );
    }
    aliasOleObject( lpobject, &olpvtbl );
    aliasOleClient( lpclient, &olpvtblc );
    rc = olecliOleCopyFromLink( lpobject, protocol, lpclient, cdoc, objname,
                                lplpobj );
    releaseAliasOleObject( lpobject, olpvtbl );
    releaseAliasOleClient( lpclient, olpvtblc );

    return( rc );

} /* __OleCopyFromLink */

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

    if( olecliOleCopyToClipboard == NULL ) {
        olecliOleCopyToClipboard = Backpatch_olecli( "OleCopyToClipboard" );
        if( olecliOleCopyToClipboard == NULL ) return( 0 );
    }

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

    return( rc );

} /* __OleCopyToClipboard */

/*
 * __OleCreate - cover function for olecli function OleCreate
 */
OLESTATUS FAR PASCAL __OleCreate(LPCSTR protocol, LPOLECLIENT lpclient,
                        LPCSTR class, LHCLIENTDOC cdoc, LPCSTR objname,
                        LPOLEOBJECT FAR*lplpobj, OLEOPT_RENDER renderopt,
                        OLECLIPFORMAT cfmt )
{
    OLESTATUS           rc;

    if( olecliOleCreate == NULL ) {
        olecliOleCreate = Backpatch_olecli( "OleCreate" );
        if( olecliOleCreate == NULL ) return( 0 );
    }

    permAliasOleClient( &lpclient );
    rc = olecliOleCreate( protocol, lpclient, class, cdoc, objname, lplpobj,
                                renderopt, cfmt );

    return( rc );

} /* __OleCreate */

/*
 * __OleCreateFromClip - cover function for olecli function OleCreateFromClip
 */
OLESTATUS FAR PASCAL __OleCreateFromClip( LPCSTR protocol, LPOLECLIENT lpclient,
                        LHCLIENTDOC cdoc, LPCSTR objname, LPOLEOBJECT FAR*lplpobj,
                         OLEOPT_RENDER renderopt, OLECLIPFORMAT cfmt )
{
    OLESTATUS           rc;

    if( olecliOleCreateFromClip == NULL ) {
        olecliOleCreateFromClip = Backpatch_olecli( "OleCreateFromClip" );
        if( olecliOleCreateFromClip == NULL ) return( 0 );
    }

    permAliasOleClient( &lpclient );
    rc = olecliOleCreateFromClip( protocol, lpclient, cdoc, objname, lplpobj,
                                renderopt, cfmt );

    return( rc );

} /* __OleCreateFromClip */

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

    if( olecliOleCreateFromFile == NULL ) {
        olecliOleCreateFromFile = Backpatch_olecli( "OleCreateFromFile" );
        if( olecliOleCreateFromFile == NULL ) return( 0 );
    }

    permAliasOleClient( &lpclient );
    rc = olecliOleCreateFromFile( protocol, lpclient, class, file, cdoc,
                                objname, lplpobj, renderopt, cfmt );

    return( rc );

} /* __OleCreateFromFile */

/*
 * __OleCreateFromTemplate - cover function for olecli function OleCreateFromTemplate
 */
OLESTATUS FAR PASCAL __OleCreateFromTemplate( LPCSTR protocol,
                        LPOLECLIENT lpclient, LPCSTR template,
                        LHCLIENTDOC cdoc, LPCSTR objname, LPOLEOBJECT FAR*lplpobj,
                        OLEOPT_RENDER renderopt, OLECLIPFORMAT cfmt )
{
    OLESTATUS           rc;

    if( olecliOleCreateFromTemplate == NULL ) {
        olecliOleCreateFromTemplate = Backpatch_olecli( "OleCreateFromTemplate" );
        if( olecliOleCreateFromTemplate == NULL ) return( 0 );
    }
    permAliasOleClient( &lpclient );
    rc = olecliOleCreateFromTemplate( protocol, lpclient, template, cdoc,
                        objname, lplpobj, renderopt, cfmt );
    return( rc );

} /* __OleCreateFromTemplate */

/*
 * __OleCreateInvisible - cover function for olecli function OleCreateInvisible
 */
OLESTATUS FAR PASCAL __OleCreateInvisible( LPCSTR protocol, LPOLECLIENT lpclient,
                         LPCSTR class, LHCLIENTDOC cdoc, LPCSTR objname,
                         LPOLEOBJECT FAR*lplpobj, OLEOPT_RENDER renderopts,
                         OLECLIPFORMAT cfmt, BOOL activate )
{
    OLESTATUS           rc;

    if( olecliOleCreateInvisible == NULL ) {
        olecliOleCreateInvisible = Backpatch_olecli( "OleCreateInvisible" );
        if( olecliOleCreateInvisible == NULL ) return( 0 );
    }

    permAliasOleClient( &lpclient );
    rc = olecliOleCreateInvisible( protocol, lpclient, class, cdoc, objname,
                lplpobj, renderopts, cfmt, activate );

    return( rc );

} /* __OleCreateInvisible */

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

    if( olecliOleCreateLinkFromClip == NULL ) {
        olecliOleCreateLinkFromClip = Backpatch_olecli( "OleCreateLinkFromClip" );
        if( olecliOleCreateLinkFromClip == NULL ) return( 0 );
    }

    permAliasOleClient( &lpclient );