/*
 * FILE.C
 *
 * Functions for handling dirty files and processing File menu commands.
 *
 * Functions:
 *  FDirtySet, FCleanVerify
 *  FFileNew, FFileOpen, FFileSave, FFileSaveAs, FFileExit
 *
 * This file contains the only functions that manipulate the fDirty flag.
 *
 * Copyright(c) Microsoft Corp. 1992-1994 All Rights Reserved
 * Win32 version, January 1994
 */


#include <windows.h>
#include <ole.h>
#include "cosmo.h"
#include "oleglobl.h"





/*
 * FDirtySet
 *
 * Purpose:
 *  Sets or clears the global 'dirty' flag returning the previous state
 *  of that same flag.  Even though the non-OLE part of this function
 *  is trivial, it isolates handling changes, providing a single point
 *  to notify a client app with OLE_CHANGED.
 *
 *  This function does exits if pGlob->fNoDirty is set.
 *
 * Parameters:
 *  fDirty          BOOL used to set the value of the pGLob->fDirty flag.
 *                  This allows us to use this function to both set and
 *                  clear the flag.  OLE_CHANGED is only sent if the
 *                  flag is set to TRUE.
 *
 * Return Value:
 *  BOOL            Previous value of the dirty flag.
 */

BOOL WINAPI FDirtySet(BOOL fDirty)
    {
    BOOL        fPrevious;

#ifdef MAKEOLESERVER
    /*
     * If we are a hidden window, then there's nothing that could make
     * us dirty since there cannot be any user interaction here.  Therefore
     * ignore any changes to the dirty flag, leaving it FALSE.
     */
    if (!IsWindowVisible(pGlob->hWnd))
        return pGlob->fDirty;

#endif //MAKEOLESERVER

    if (pGlob->fNoDirty)
        return pGlob->fDirty;

    fPrevious=pGlob->fDirty;
    pGlob->fDirty=fDirty;

#ifdef MAKEOLESERVER
    if (fDirty)
        //Fun indirection, huh?  That what you get with an OOP.
        OLEClientNotify(pOLE->pSvr->pDoc->pObj, OLE_CHANGED);
#endif //MAKEOLESERVER

    return fPrevious;
    }





/*
 * FCleanVerify
 *
 * Purpose:
 *  Checks the pGLob->fDirty flag, and if set, displays a message
 *  box informing the user that the file is dirty and asking if
 *  the file should be saved or updated.  If YES is chosen, the file
 *  is saved or updated.
 *
 * Parameters:
 *  pGlob           LPGLOBALS to global variable block.
 *
 * Return Value:
 *  BOOL            TRUE if it's safe to proceed with the operation (file
 *                  is clean, user answered NO, or file was saved).
 *                  FALSE if the user wants to cancel the operation or there
 *                  was an error.
 */

BOOL WINAPI FCleanVerify(LPGLOBALS pGlob)
    {
    BOOL        fRet=TRUE;
    UINT        uRet;
    char       *psz;

#ifdef MAKEOLESERVER
    char        szClient[40];
#endif //MAKEOLESERVER

    //Nothing to do if we're clean.
    if (!pGlob->fDirty)
        return TRUE;

    if (!pGlob->fOLE)
        {
        uRet=MessageBox(pGlob->hWnd, rgpsz[IDS_FILEDIRTY]
            , rgpsz[IDS_CAPTION], MB_YESNOCANCEL | MB_ICONEXCLAMATION);
        }
#ifdef MAKEOLESERVER
    if (pGlob->fOLE)
        {
        //Linking case, use the same message as before.
        if (pOLE->pSvr->fLink)
            {
            uRet=MessageBox(pGlob->hWnd, rgpsz[IDS_FILEDIRTY],
                            rgpsz[IDS_CAPTION], MB_YESNOCANCEL);
            }

        //Embedding: Ask the user about updating instead of saving.
        if (pOLE->pSvr->fEmbed)
            {
            //Build the standard string for Updating.
            psz=(PSTR)LocalAlloc(LPTR, 1024);

            if (NULL==psz)
                return FALSE;

            GetAtomName(pOLE->pSvr->pDoc->aClient, szClient, sizeof(szClient));

            lstrcpy(psz, rgpsz[IDS_CLOSEALERT1]);
            lstrcat(psz, szClient);
            lstrcat(psz, rgpsz[IDS_CLOSEALERT2]);

            uRet=MessageBox(pGlob->hWnd, psz, rgpsz[IDS_CAPTION],
                            MB_YESNOCANCEL | MB_ICONEXCLAMATION);

            LocalFree((HLOCAL)psz);
            }
        }
#endif //MAKEOLESERVER

    switch (uRet)
        {
        case IDCANCEL:
            fRet=FALSE;
            break;

        case IDNO:
            fRet=TRUE;
            break;

        case IDYES:
            if (!pGlob->fOLE)
                fRet=FFileSave(pGlob);

#ifdef MAKEOLESERVER
            //Linking same as stand-alone.
            if (pOLE->pSvr->fLink)
                fRet=FFileSave(pGlob);

            if (pOLE->pSvr->fEmbed)
                OLEClientNotify(pOLE->pSvr->pDoc->pObj, OLE_CLOSED);

#endif //MAKEOLESERVER
            break;
        }

    return fRet;
    }






/*
 * FFileNew
 *
 * Purpose:
 *  Confirms the new file with the user and cleans out the Polyline
 *  image.
 *
 * Parameters:
 *  pGlob           LPGLOBALS to the global variable block.
 *
 * Return Value:
 *  BOOL            TRUE if the function succeeded, FALSE otherwise.
 *
 */

BOOL WINAPI FFileNew(LPGLOBALS pGlob)
    {
    if (!FCleanVerify(pGlob))
        return FALSE;

#ifdef MAKEOLESERVER
    PDocRevokeAndCreate(pOLE);
#endif //MAKEOLESERVER

    pGlob->fOLE=FALSE;

    SendMessage(pGlob->hWndPolyline, PLM_POLYLINENEW, 0, 0L);
    pGlob->fDirty=FALSE;
    pGlob->fOpenFile=FALSE;

    WindowTitleSet(pGlob->hWnd, rgpsz[IDS_UNTITLED]);
    return TRUE;
    }




/*
 * FFileOpen
 *
 * Purpose:
 *  Confirms that the user wants to open a new file and invokes the
 *  common dialog file open to get the filename, then reads the
 *  contents of the file.  If the fImport flag is TRUE, then we
 *  import the contents of the file into the current document,
 *  not changing the document name or any of the UI.
 *
 * Parameters:
 *  pGlob           LPGLOBALS to the global variable block.
 *  fImport         BOOL indicates if we're importing from a file,
 *                  not affecting the current filename.
 *
 * Return Value:
 *  BOOL            TRUE if the function succeeded, FALSE otherwise.
 *
 */

BOOL WINAPI FFileOpen(LPGLOBALS pGlob, BOOL fImport)
    {
    POLYLINE        pl;
    BOOL            fOK;
    LPSTR           psz;
    char            szTemp[CCHPATHMAX];
    LPSTR           pszFile;

    if (!fImport)
        {
        if (!FCleanVerify(pGlob))
            return FALSE;
        }

    psz=(fImport) ? rgpsz[IDS_FILEIMPORT] : rgpsz[IDS_FILEOPEN];

    //We have to use a temp for Import or else we'll wipe out a real filename.
    pszFile=(fImport) ? (LPSTR)szTemp : (LPSTR)pGlob->szFile;

    fOK=FSaveOpenDialog(pGlob->hWnd, pGlob->hInst, rgpsz[IDS_DEFEXT]
        , rgpsz[IDS_FILEOPENFILTER], pszFile, psz, TRUE);


    if (fOK)
        {
        //Attempt to read the file in and display it.
        if (!FCosFileRead(pGlob, pszFile, &pl))
            return FALSE;

#ifdef MAKEOLESERVER
        if (!fImport)
            PDocRevokeAndCreate(pOLE);
#endif //MAKEOLESERVER

        SendMessage(pGlob->hWndPolyline, PLM_POLYLINESET,
                    TRUE, (LONG)(LPSTR)&pl);

        if (!fImport)
            {
            WindowTitleSet(pGlob->hWnd, pszFile);
            pGlob->fOLE=FALSE;

            pGlob->fOpenFile=TRUE;
            pGlob->fDirty=FALSE;
            }
        else
            pGlob->fDirty=TRUE;
        }

    return fOK;
    }






/*
 * FFileSave
 *
 * Purpose:
 *  Writes the file to a known filename, requiring that the user has
 *  previously used FileOpen or FileSaveAs in order to have a filename.
 *
 * Parameters:
 *  pGlob           LPGLOBALS to the global variable block.
 *
 * Return Value:
 *  BOOL            TRUE if the function succeeded, FALSE otherwise.
 *
 */

BOOL WINAPI FFileSave(LPGLOBALS pGlob)
    {
    POLYLINE        pl;

#ifdef MAKEOLESERVER
    OLESTATUS       os;

    //In OLE cases, this may be Update; call OleSavedServerDoc
    if (pGlob->fOLE)
        {
        if (pOLE->pSvr->fLink)
            {
            SendMessage(pGlob->hWndPolyline, PLM_POLYLINEGET, 0,
                        (LONG)(LPSTR)&pl);

            if (!FCosFileWrite(pGlob, pGlob->szFile, &pl))
                return FALSE;
            }

        //This notifies the client for us.
        os=OleSavedServerDoc(pOLE->pSvr->pDoc->lh);

        pGlob->fDirty=(BOOL)(OLE_OK!=os);
        return !pGlob->fDirty;
        }

#endif //MAKEOLESERVER

    if (!pGlob->fOpenFile)
        return FFileSaveAs(pGlob);

    SendMessage(pGlob->hWndPolyline, PLM_POLYLINEGET, 0, (LONG)(LPSTR)&pl);

    if (!FCosFileWrite(pGlob, pGlob->szFile, &pl))
        return FALSE;

    pGlob->fOpenFile=TRUE;
    pGlob->fDirty=FALSE;
    return TRUE;
    }






/*
 * FFileSaveAs
 *
 * Purpose:
 *  Invokes the common dialog for Save As to get a filename then
 *  writes the polyline data to that file, creating if necessary.
 *
 * Parameters:
 *  pGlob           LPGLOBALS to the global variable block.
 *
 * Return Value:
 *  BOOL            TRUE if the function succeeded, FALSE otherwise.
 *
 */

BOOL WINAPI FFileSaveAs(LPGLOBALS pGlob)
    {
    POLYLINE        pl;
    BOOL            fOK;

    fOK=FSaveOpenDialog(pGlob->hWnd, pGlob->hInst, rgpsz[IDS_DEFEXT]
        , rgpsz[IDS_FILEOPENFILTER], pGlob->szFile, rgpsz[IDS_FILESAVEAS]
        , FALSE);

    if (fOK)
        {
        SendMessage(pGlob->hWndPolyline, PLM_POLYLINEGET
            , 0, (LONG)(LPSTR)&pl);

        fOK=FCosFileWrite(pGlob, pGlob->szFile, &pl);

#ifdef MAKEOLESERVER
        /*
         * In the Save Copy As case, when an object is embedded, we
         * don't need to call Rename or Saved since we just saved a
         * silent copy of the data.
         */
        if (pGlob->fOLE && pOLE->pSvr->fEmbed)
            return fOK;

        if (fOK && pGlob->fOLE && pOLE->pSvr->fLink)
            {
            OleRenameServerDoc(pOLE->pSvr->pDoc->lh, pGlob->szFile);
            OleSavedServerDoc(pOLE->pSvr->pDoc->lh);
            }
#endif //MAKEOLESERVER

        pGlob->fOpenFile=fOK;
        WindowTitleSet(pGlob->hWnd, pGlob->szFile);
        pGlob->fDirty=FALSE;
        }

    return fOK;
    }



/*
 * FFileExit
 *
 * Purpose:
 *  Handles the File/Exit menu command, verifying dirty files as necessary
 *  and revoking the server.
 *
 * Parameters:
 *  pGlob           LPGLOBALS to the global variable block.
 *
 * Return Value:
 *  BOOL            TRUE if the application can exit, FALSE otherwise.
 */

BOOL WINAPI FFileExit(LPGLOBALS pGlob)
    {
    BOOL            fRet;
#ifdef MAKEOLESERVER
    OLESTATUS       os;
    LHSERVER        lhT;
#endif //MAKEOLESERVER

    if (!FCleanVerify(pGlob))
        return FALSE;

#ifdef MAKEOLESERVER
    lhT=pOLE->pSvr->lh;
    pOLE->pSvr->lh=0L;
    os=OleRevokeServer(lhT);

    if (OLE_WAIT_FOR_RELEASE==os)
        {
        pOLE->pSvr->fRelease=FALSE;
        FOLEReleaseWait(&pOLE->pSvr->fRelease, lhT);
        fRet=TRUE;
        }
    else
        fRet=(OLE_OK==os);
#endif //MAKEOLESERVER

    return fRet;
    }