Windows编程

开发平台：
Visual C++

OLESVR.C：源码内容
							/*
 * OLESVR.C
 *
 * Contains all callback functions in the OLESERVERVTBL struture:
 *      ServerCreate
 *      ServerCreateFromTemplate
 *      ServerEdit
 *      ServerExecute
 *      ServerExit
 *      ServerOpen
 *      ServerRelease
 *
 * Also includes the constructor function PServerAllocate.
 *
 * Copyright(c) Microsoft Corp. 1992-1994 All Rights Reserved
 * Win32 version, January 1994
 */
#ifdef MAKEOLESERVER
#include <windows.h>
#include <ole.h>
#include "cosmo.h"
#include "oleglobl.h"
/*
 * PServerAllocate
 *
 * Purpose:
 *  Allocates a COSMOSERVER structure and sets the defaults in its fields.
 *  Used from application initialization.
 *
 * Parameters:
 *  pVtblSvr        LPOLESERVERVTBL used to initialize the pvtbl field.
 *
 * Return Value:
 *  LPCOSMOSERVER   Pointer to the allocated structure in local memory.
 *                  The hMem field will contain a handle to the structure
 *                  to pass to LocalFree.
 *
 */
LPCOSMOSERVER WINAPI PServerAllocate(LPOLESERVERVTBL pVtblSvr)
    {
    HLOCAL            hMem;
    LPCOSMOSERVER     pSvr;
    hMem=LocalAlloc(LPTR, CBCOSMOSERVER);
    if (NULL==hMem)
        return FALSE;
    pSvr=(LPCOSMOSERVER)(PSTR)hMem;
    //All fields are initially NULL from LMEM_ZEROINIT.
    pSvr->hMem=hMem;
    pSvr->pvtbl=pVtblSvr;
    pSvr->fRelease=TRUE;            //Indicate a released state.
    return pSvr;
    }
/*
 * ServerCreate
 *
 * Purpose:
 *  Creates a new object of the class in pszClass which will be
 *  embedded in a client application document whose name is in
 *  pszDoc.
 *
 * Parameters:
 *  pSvr            LPCOSMOSERVER to structure identifying the server.
 *  lhDoc           LHSERVERDOC identifying the document.
 *  pszClass        OLE_LPCSTR specifying the class of document to create.
 *  pszDoc          OLE_LPCSTR specifying the document for use in window titles.
 *  ppServerDoc     LPLPOLESERVERDOC in which to store a pointer
 *                  to the OLESERVERDOC structure for this new document.
 *
 * Return Value:
 *  OLESTATUS       OLE_OK if all is well, otherwise an OLE_* error value.
 */
OLESTATUS WINAPI ServerCreate(LPCOSMOSERVER pSvr, LHSERVERDOC lhDoc
    , OLE_LPCSTR pszClass, OLE_LPCSTR pszDoc, LPLPOLESERVERDOC ppServerDoc)
    {
    LPCOSMODOC      pDoc;
    /*
     * 1.   Create a document of the specified class.
     * 2.   Allocate and initialize an OLESERVERDOC structure.
     * 3.   Store lhDoc in the OLESERVERDOC structure.
     * 4.   Store a pointer to the new OLESERVERDOC structure in ppServerDoc.
     * 5.   Return OLE_OK if successful, OLE_ERROR_NEW otherwise.
     */
    /*
     * If this were an MDI application, then we would want to create
     * a new window and a new document, including a new OLESERVERDOC
     * structure.  The protocol supports this, however, this application
     * is single-document.
     */
    pDoc=PDocumentAllocate(&pOLE->vtblDoc);
    if ((LPCOSMODOC)NULL==pDoc)
        return OLE_ERROR_NEW;
    pSvr->pDoc=pDoc;
    pDoc->lh=lhDoc;
    *ppServerDoc=(LPOLESERVERDOC)pDoc;
    return OLE_OK;
    }
/*
 * ServerCreateFromTemplate
 *
 * Purpose:
 *  Creates a new document initialized with the data in a specified
 *  file.  Thw new document is opened for editing and is embedded
 *  within the client when the server is updated or closed.
 *
 * Parameters:
 *  pSvr            LPCOSMOSERVER to structure identifying the server.
 *  lhDoc           LHSERVERDOC identifying the document.
 *  pszClass        OLE_LPCSTR specifying the class of document to create.
 *  pszDoc          OLE_LPCSTR to the permanent name of the document to open.
 *  pszTemp         OLE_LPCSTR to the file to use as a template.
 *  ppServerDoc     LPLPOLESERVERDOC in which to store a pointer
 *                  to the OLESERVERDOC structure for this new document.
 *
 * Return Value:
 *  OLESTATUS       OLE_OK if all is well, otherwise an OLE_* error value.
 */
OLESTATUS WINAPI ServerCreateFromTemplate(LPCOSMOSERVER pSvr
    , LHSERVERDOC lhDoc, OLE_LPCSTR pszClass, OLE_LPCSTR pszDoc
    , OLE_LPCSTR pszTemp, LPLPOLESERVERDOC ppServerDoc)
    {
    POLYLINE        pl;
    LPCOSMODOC      pDoc;
    /*
     * 1.   Create a document of the specified class.
     * 2.   Read the contents of the specified file and initialize the document.
     * 3.   Allocate and initialize an OLESERVERDOC structure.
     * 4.   Store lhDoc in the OLESERVERDOC structure.
     * 5.   Store a pointer to the new OLESERVERDOC structure in ppServerDoc.
     * 6.   Return OLE_OK if successful, OLE_ERROR_TEMPLATE otherwise.
     */
    //pszTemp contains a filename.
    if (!FCosFileRead(pGlob, (LPSTR)pszTemp, &pl))
        return OLE_ERROR_TEMPLATE;
    pDoc=PDocumentAllocate(&pOLE->vtblDoc);
    if ((LPCOSMODOC)NULL==pDoc)
        return OLE_ERROR_TEMPLATE;
    pSvr->pDoc=pDoc;
    pDoc->lh=lhDoc;
    *ppServerDoc=(LPOLESERVERDOC)pDoc;
    SendMessage(pGlob->hWndPolyline, PLM_POLYLINESET, TRUE, (LONG)(LPSTR)&pl);
    //The titles in this window will be set later through SetHostNames.
    pGlob->fOpenFile=TRUE;
    return OLE_OK;
    }
/*
 * ServerEdit
 *
 * Purpose:
 *  Creates a document initialized with data from a subsequent call
 *  to the SetData function.  The object is embedded in the client
 *  application and the server is not visible.
 *
 * Parameters:
 *  pSvr            LPCOSMOSERVER to structure identifying the server.
 *  lhDoc           LHSERVERDOC identifying the document.
 *  pszClass        OLE_LPCSTR specifying the class of document to create.
 *  pszDoc          OLE_LPCSTR specifying the document for use in window titles.
 *  ppServerDoc     LPLPOLESERVERDOC in which to store a pointer
 *                  to the OLESERVERDOC structure for this new document.
 *
 * Return Value:
 *  OLESTATUS       OLE_OK if all is well, otherwise an OLE_* error value.
 */
OLESTATUS WINAPI ServerEdit(LPCOSMOSERVER pSvr, LHSERVERDOC lhDoc
    , OLE_LPCSTR pszClass, OLE_LPCSTR pszDoc, LPLPOLESERVERDOC ppServerDoc)
    {
    LPCOSMODOC      pDoc;
    /*
     * This is the same as Open, but tells the server to expect
     * a SetData call and that the server is initially hidden.
     *
     * 1.   Create a document of the specified class.
     * 2.   Allocate and initialize an OLESERVERDOC structure.
     * 3.   Store lhDoc in the OLESERVERDOC structure.
     * 4.   Store pointer to the new OLESERVERDOC structure in ppServerDoc.
     * 5.   Return OLE_OK if successful, OLE_ERROR_EDIT otherwise.
     */
    pDoc=PDocumentAllocate(&pOLE->vtblDoc);
    if ((LPCOSMODOC)NULL==pDoc)
        return OLE_ERROR_EDIT;
    pSvr->pDoc=pDoc;
    pDoc->lh=lhDoc;
    *ppServerDoc=(LPOLESERVERDOC)pDoc;
    return OLE_OK;
    }
/*
 * ServerExecute
 *
 * Purpose:
 *  Handles DDE Execute commands sent from the server library
 *  from the client application.  Not all applications need to support
 *  DDE Execute.
 *
 * Parameters:
 *  pSvr            LPCOSMOSERVER identifying the server closing.
 *  hCommands       HGLOBAL to memory containing the DDE execute
 *                  string.
 *
 * Return Value:
 *  OLESTATUS       OLE_OK if all is well, otherwise an OLE_* error value.
 *                  This functions returns OLE_ERROR_COMMAND to indicate
 *                  that it is not implemented.
 */
OLESTATUS WINAPI ServerExecute(LPCOSMOSERVER pSvr, HGLOBAL hCommands)
    {
    /*
     * 1.   Lock the hCommands handle to access the execute strings.
     * 2.   Parse and execute the commands as necessary.
     * 3.   DO NOT FREE hCommands.
     * 4.   Return OLE_OK if successful, OLE_ERROR_COMMAND otherwise.
     */
    return OLE_ERROR_COMMAND;
    }
/*
 * ServerExit
 *
 * Purpose:
 *  Instructs the server application to close documents and shut down.
 *
 * Parameters:
 *  pSvr            LPCOSMOSERVER identifying the server closing.
 *
 * Return Value:
 *  OLESTATUS       OLE_OK if all is well, otherwise an OLE_* error value.
 */
OLESTATUS WINAPI ServerExit(LPCOSMOSERVER pSvr)
    {
    /*
     * 1.   Hide the window to prevent any user interaction.
     * 2.   Call OleRevokeServer.  Ignore an OLE_WAIT_FOR_RELEASE return value.
     * 3.   Perform whatever action is necessary to cause the application
     *      to terminate, such as DestroyWindow.
     * 4.   Return OLE_OK if successful, OLE_ERROR_GENERIC otherwise.
     */
    ShowWindow(pGlob->hWnd, SW_HIDE);
    pSvr->fRelease=FALSE;
    OleRevokeServer(pSvr->lh);
    DestroyWindow(pGlob->hWnd);
    return OLE_OK;
    }
/*
 * ServerOpen
 *
 * Purpose:
 *  Opens an exiting file (document) and prepares the document for
 *  editing, generally done when a user double-clicks a linked
 *  object in the client.  Note that the server is hidden at this
 *  point.
 *
 * Parameters:
 *  pSvr            LPCOSMOSERVER to structure identifying the server.
 *  lhDoc           LHSERVERDOC identifying the document.
 *  pszDoc          OLE_LPCSTR to the permanent name of the document to
 *                  be opened.
 *  ppServerDoc     LPLPOLESERVERDOC in which to store a pointer
 *                  to the OLESERVERDOC structure for this new document.
 *
 * Return Value:
 *  OLESTATUS       OLE_OK if all is well, otherwise an OLE_* error value.
 */
OLESTATUS WINAPI ServerOpen(LPCOSMOSERVER pSvr, LHSERVERDOC lhDoc
    , OLE_LPCSTR pszDoc, LPLPOLESERVERDOC ppServerDoc)
    {
    POLYLINE        pl;
    LPCOSMODOC      pDoc;
    /*
     * 1.   Create a document of the specified class.
     * 2.   Read the contents of the specified file and initialize the document.
     * 3.   Save the filename of the loaded file with this document,
     *      if necessary.
     * 4.   Allocate and initialize an OLESERVERDOC structure.
     * 5.   Store lhDoc in the OLESERVERDOC structure.
     * 6.   Store a pointer to the new OLESERVERDOC structure in ppServerDoc.
     * 7.   Return OLE_OK if successful, OLE_ERROR_OPEN otherwise.
     */
    if (!FCosFileRead(pGlob, (LPSTR)pszDoc, &pl))
        return OLE_ERROR_OPEN;
    pDoc=PDocumentAllocate(&pOLE->vtblDoc);
    if ((LPCOSMODOC)NULL==pDoc)
        return OLE_ERROR_OPEN;
    //Save the document in the server for later access in ServerRelease.
    pSvr->pDoc=pDoc;
    pDoc->lh=lhDoc;
    *ppServerDoc=(LPOLESERVERDOC)pDoc;
    WindowTitleSet(pGlob->hWnd, (LPSTR)pszDoc);
    SendMessage(pGlob->hWndPolyline, PLM_POLYLINESET, TRUE, (LONG)(LPSTR)&pl);
    pGlob->fOpenFile=TRUE;
    return OLE_OK;
    }
/*
 * ServerRelease
 *
 * Purpose:
 *  Notifies a server that all connections to it have been closed and
 *  that the server application can terminate.  This function should
 *  change the state of a global flag that causes any PeekMessage
 *  waiting loop to exit.
 *
 * Parameters:
 *  pSvr            LPCOSMOSERVER identifying the server.
 *
 * Return Value:
 *  OLESTATUS       OLE_OK if all is well, otherwise an OLE_* error value.
 */
OLESTATUS WINAPI ServerRelease(LPCOSMOSERVER pSvr)
    {
    /*
     * 1.   Set a flag to indicate that Release has been called.
     * 2.   If the application is hidden, we must use ServerRelease to
     *      instruct the application to terminate, by posting a WM_CLOSE
     *      or otherwise effective message, then exit the method with OLE_OK.
     * 3.   Free any resources allocated for this server, like documents,
     *      but DO NOT free the OLESERVER structure itself.
     * 4.   Return OLE_OK if successful, OLE_ERROR_GENERIC otherwise.
     */
    pSvr->fRelease=TRUE;
    /*
     * If we are invisible when we get ServerRelease, that's a flag
     * to us meaning exit.  Posting a WM_CLOSE takes care of all
     * this.  Note that even though WM_CLOSE processing in COSMO.C
     * checks for a dirty file and asks to save if necessary, the
     * file cannot be dirty because there has been no chance for
     * the user to make any changes.
     *
     * ServerRelease may be called twice when the server is opened invisible
     * for an update of a client object.  In this case, we'll get
     * ServerRelease once, where we should post a message to terminate the
     * application.  The second time around we need to handle free resources
     * associated with the server.  We detect this through the validity
     * pOLE->pSvr->lh which we set to 0L in FFileExit before calling
     * OleRevokeServer.  0L in lh signals us that we're in the final
     * revoke and we can free documents.
     *
     */
    if (!IsWindowVisible(pGlob->hWnd) && 0L!=pOLE->pSvr->lh)
        {
        PostMessage(pGlob->hWnd, WM_CLOSE, 0, 0L);
        return OLE_OK;
        }
    /*
     * Free the document if we are closing from OleRevokeServer, not through
     * a client releasing the server.
     */
    if (0L==pOLE->pSvr->lh)
        {
        //Free the document we're holding.
        if (NULL!=pSvr->pDoc)
            {
            if (NULL!=pSvr->pDoc->hMem)
                LocalFree(pSvr->pDoc->hMem);
            }
        pSvr->pDoc=NULL;
        }
    return OLE_OK;
    }
#endif //MAKEOLESERVER

						