windows-xp/Source/XPSP1/NT/base/mvdm/wow16/write/trans3.c

/************************************************************/
/* Windows Write, Copyright 1985-1992 Microsoft Corporation */
/************************************************************/

/* trans3.c: more save routines, moved here from trans2.c because of compiler
 heap space errors */

#define NOVIRTUALKEYCODES
#define NOWINSTYLES
#define NOCLIPBOARD
#define NOGDICAPMASKS
#define NOSYSMETRICS
#define NOMENUS
#define NOMSG
#define NOKEYSTATE
#define NOSHOWWINDOW
//#define NOGDI
#define NOFONT
#define NOBRUSH
#define NOBITMAP
//#define NOATOM
#define NOMETAFILE
#define NOPEN
#define NOPOINT
#define NORECT
#define NOREGION
#define NOHRGN
#define NOCOLOR
#define NODRAWTEXT
//#define NOTEXTMETRIC
#define NOWINOFFSETS
#define NOCREATESTRUCT
#define NOWH
#define NOSOUND
#define NOSCROLL
#define NOCOMM
#define NOWNDCLASS
/* need memmgr, mb */
#include <windows.h>

#include "mw.h"
#include "doslib.h"
#include "cmddefs.h"
#include "docdefs.h"
#include "filedefs.h"
#include "editdefs.h"
#include "printdef.h"
#define NOSTRUNDO
#include "str.h"
#include "debug.h"
#include "fontdefs.h"
#include "dlgdefs.h"
#include "winddefs.h"
#include "macro.h"
#include "preload.h"
#include "io.h"
#if defined(OLE)
#include "obj.h"
#endif

#define WRITE_PERMISSION 02 /* flag to access() */

CHAR    *index( CHAR *, CHAR );
CHAR    *PchGetPn();
CHAR    *PchFromFc();
static int fOpenedFormatted = TRUE;
int   vfOldWriteFmt=FALSE;  /* delete objects before saving */
DoFileOpen( LPSTR );

BOOL CheckEnableButton(HANDLE, HANDLE);
BOOL NEAR PASCAL CanReadEveryFile(char *szFilename);

extern CHAR    szExtSearch[]; /* store default search spec */
extern CHAR szWriteProduct[];
extern CHAR szBackup[];
extern int vfTextOnlySave;

extern int         vfCursorVisible;
extern int         vfDiskError;
extern int         vfSysFull;
extern HWND        vhWndMsgBoxParent;
extern int         vfnWriting;
extern CHAR        (**vhrgbSave)[];
extern struct DOD      (**hpdocdod)[];
extern int         docCur;
extern int         docScrap;
extern int         docUndo;
extern struct FCB      (**hpfnfcb)[];
extern int         vfBuffersDirty;
extern int         vfDiskFull;
extern typeCP          vcpFetch;
extern CHAR        *vpchFetch;
extern int         vccpFetch;
extern typeCP          vcpLimParaCache;
extern int         vfDeactByOtherApp;
extern BOOL        vfWarnMargins;

#ifdef INTL /* International version */
extern int         vWordFmtMode;
#ifdef INEFFLOCKDOWN
extern FARPROC lpDialogWordCvt;
#else
extern BOOL far PASCAL DialogWordCvt(HWND, unsigned, WORD, LONG);
#endif
#endif  /* International version */

static unsigned wMerge;  /* for message merge code */

extern int         vfBackupSave;

extern int      ferror;
extern CHAR     szExtBackup[];
extern CHAR     (**hszTemp)[];
#ifdef INEFFLOCKDOWN
extern FARPROC lpDialogOpen;
extern FARPROC lpDialogSaveAs;
#endif


extern HANDLE  hMmwModInstance;
extern HANDLE  hParentWw;
extern HCURSOR vhcHourGlass;
extern HCURSOR vhcIBeam;
extern HCURSOR vhcArrow;

    /* Used in this module only */
static CHAR *pchSet;
static CHAR szUser[ cchMaxFile ]; /* store whatever is in idiOpenFile (ANSI) */

#define SF_OLDWRITE 0
#define SF_WORD     1
BOOL WannaDeletePictures(int doc, int fWhichFormat);
BOOL DocHasPictures(int doc);
NEAR DlgAddCorrectExtension(CHAR *, int);
BOOL  (NEAR FSearchSpec(CHAR *));
BOOL far PASCAL DialogOpen(HWND, unsigned, WORD, LONG);
BOOL far PASCAL DialogSaveAs(HWND, unsigned, WORD, LONG);


#ifdef INTL /* International version */
BOOL  FInWordFormat(int);
void ConvertFromWord();
#endif  /* International version */


fnOpenFile(LPSTR lpstrFileName) // filename may be NULL
{
 extern int vfCloseFilesInDialog;
 extern int docCur;
 extern HANDLE hMmwModInstance;
 extern HANDLE hParentWw;
 extern struct SEL selCur;
 extern typeCP cpMinDocument;

 /* Close all files on removable media for every message we get */
 vfCloseFilesInDialog = TRUE;

 /* Close all files on removable media so changing disks is safe */
 CloseEveryRfn( TRUE );

 /* test for dirty file and offer opportunity to save */

 if (FConfirmSave())
    DoFileOpen(lpstrFileName);

 vfCloseFilesInDialog = FALSE;
}

DoFileOpen( LPSTR lpstrFileName ) // filename may be NULL )
{
    /* return whether error.  Use CommDlg for open dialog (3.8.91) D. Kent */
    /* ********* International version changes bz 2/21/86 *************
    For files opened in Word format and converted to Write format
    the following changes are made:
       the vWordFmtMode flag is left set to CONVFROMWORD. The file is
       saved, effecting the change to Word format, but the original
       Word file in not renamed, so it is left untouched, with no need to
       make a backup. On the next save, we ask if the file with that name
       (the Word document) should be replaced, so any file with that
       name that existed will be protected.
    *************************************************************** */

    extern int vfDiskError;
    int fn=fnNil;
    int doc;
    CHAR (**hsz)[] = NULL;
    int nRetval=FALSE;
    CHAR rgch[cchMaxFile];
    extern DoOpenFilenameGet(LPSTR);
    BOOL bOpened=TRUE,      // ObjOpenedDoc has succeeded
         bCancelled=FALSE;

#ifdef INTL /* International version */
int fWordDoc;
#endif  /* International version */

    EnableOtherModeless(FALSE);

    /* prevent WM_PAINT from painting a doc that isn't defined */

    while(1)
    {
        bCancelled = FALSE;

        if (lpstrFileName)
            lstrcpy(rgch,lpstrFileName);
        else if (!DoOpenFilenameGet(rgch))
        {
            bCancelled = TRUE;
            goto KeepTrying;
        }
        else if (rgch[0] == '\0')
        {
            bCancelled = TRUE;
            goto KeepTrying;
        }

#if defined(OLE)
        if (bOpened) 
            if (ObjClosingDoc(docCur,rgch))
            /*  
                If this failed, then we could't close this document, much less
                open a new one.
            */
                break; // from while
            else
            /**
                At this point, docCur is OLE-closed!!!  Gotta be sure we
                open a new one!!! 
            **/
                bOpened = FALSE;
#endif


        if ((fn = FnOpenSz( rgch, dtyNormNoExt, FALSE)) == fnNil)
        /* this has side effect of setting &(**(**hpfnfcb) [fn].hszFile) [0] 
        to "normalized" filename. */
        {
            /* Open failed */
            goto KeepTrying;
        }
        else
        {   /* Opened file OK */
            /* Set caption to "Loading file..." */

            extern CHAR szLoadFile[];
            extern CHAR szCvtLoadFile[];

#ifdef INTL /* International version */
            /* **************************************
            * added check for international version to
                    do Word format conversion. If Word format,
                    bring up another dialog box.
            * ************************************** */

            /* TestWordCvt return values:

            -1 means dialog box failed (error already sent)
            -2 means cancel without conversion.
            FALSE means not a word document.
            TRUE means convert this word document.
            *** as of 2/14/86, we changed the conversion
            to not make a backup, but to save the file
            in write format without renaming the Word
            file, so the word file is effectively
            backed up under its original name. See
            CleanDoc in trans2.c for explanations.
            */

            switch ((fWordDoc = TestWordCvt (fn, hParentWw)))
            {
                case -2: // CANCEL
                    bCancelled = TRUE;
                    // fall through..

                case -1: // ERROR
                    /* Release this fn! */
                    FreeFn(fn);
                    CloseEveryRfn( TRUE );
                    goto KeepTrying;
            }

            /* if true, will convert soon */
            if (fWordDoc)
                {
                SetWindowText(hParentWw, (LPSTR)szCvtLoadFile);
                }
            else
#endif  /* International version */
                SetWindowText(hParentWw, (LPSTR)szLoadFile);

            StartLongOp();

            ReadFilePages( fn );
        }

        Assert( fn != fnNil );
        bltsz( &(**(**hpfnfcb) [fn].hszFile) [0], rgch );

        CchCopySz(rgch, szUser);

        hsz=NULL;

        if ( !FNoHeap(hsz = HszCreate( (PCH) rgch )) )
        {
            if ((doc = DocCreate( fn, hsz, dtyNormal )) != docNil)
            {   /* Succeeded in creating document */

                KillDoc( docCur );
                docCur = doc;
                hsz = NULL; // don't free cause used by doc

#ifdef INTL /* International version */
            /* if a word document to be converted, save it doing conversion. */
                if (fWordDoc)
                {
                    /* save file in write format. */
                    ConvertFromWord();
                    vfTextOnlySave = FALSE;
                    (**hpdocdod)[docCur].fDirty = TRUE;
                }
#endif  /* International version */

                ChangeWwDoc( szUser );
                /* Ensure that the margins of this document is right
                for the printer. */
                vfWarnMargins = TRUE;
                SetPageSize();
                vfWarnMargins = FALSE;
#if defined(OLE)
                if (ObjOpenedDoc(docCur)) 
                /* Couldn't open.  Must try to open a new one */
                    goto KeepTrying;
                else
                {
                    bOpened = TRUE;
                    break; // from while loop 'cause we're done
                }
#endif
            }
#if defined(JAPAN) || defined(KOREA)                  //  added  10 Jun. 1992  by Hiraisi
           else{
               bCancelled = TRUE;
               goto KeepTrying;
           }
#endif
        }

        KeepTrying:
        /* get to here either because error or cancelled */

        vfDiskError = ferror = FALSE;
        SetTitle( **(**hpdocdod)[ docCur ].hszFile );

        if (hsz)
        {
            FreeH( hsz );
            hsz=NULL;
        }

        CloseEveryRfn( TRUE );

        EndLongOp(vhcArrow);

        if (bCancelled)
        /* can't cancel unless we have an opened document */
        {
            if (!bOpened) // currently no open doc
            {
                if (bOpened = !ObjOpenedDoc(docCur)) // returns FALSE if success
                    break;
            }
            else
                break;
        }

    }  // end of while(1)


#if WINVER >= 0x300
    FreeUnreferencedFns();
#endif

    EndLongOp(vhcArrow);
    EnableOtherModeless(TRUE);
    return !bOpened;

} /* end of DoFileOpen */




fnSave()
{   /* Entry point for the "Save" command */
    extern int vfCloseFilesInDialog;
    extern int vfOutOfMemory;
    extern HANDLE vhReservedSpace;
                        
    struct DOD *pdod = &(**hpdocdod)[docCur];
    CHAR *psz = &(**(pdod->hszFile))[0];

    if (!CanReadEveryFile(psz))
        return;

#if WINVER >= 0x300
    if (pdod->fReadOnly)
        {
        /* Read-only doc: tell the user to save under a different name */

        Error( IDPMTReadOnly );
        ferror = FALSE; /* Not really an error */
        
        fnSaveAs();  /* May as well take them there now! ..pault 10/20/89 */
        }
    else if (psz [0] == '\0' || vWordFmtMode == CONVFROMWORD)
        /* Any time the user has converted the current Write document
           from a Word or Text document, we force them through the 
           FileSaveAs dlg box when Saving.  In this way we remind them
           that they might want to change the name -- but if they don't
           want to, that's ok and we'll not bother them any more about it
           (fnSaveAs dialog box will reset vWordFmtMode) ..pault 9/18/89 */
#else /* old windows */
    else if (psz [0] == '\0')
#endif
        fnSaveAs();
    else
        {

        if (vfOldWriteFmt || (vWordFmtMode & ~CONVFROMWORD) || vfTextOnlySave)
        /* then deleting pictures */
        {
            if (vfOldWriteFmt || vfTextOnlySave)
                vcObjects = ObjEnumInDoc(docCur,NULL);
            if (!WannaDeletePictures(docCur,vfOldWriteFmt ? SF_OLDWRITE : SF_WORD))
                return;
        }

        vfCloseFilesInDialog = TRUE;

        /* Close all files on removable media so changing disks is safe */

        CloseEveryRfn( TRUE );

        /* Free the reserved block, to give us memory for the save dialog box
           and for CmdXfSave */
        if (vhReservedSpace != NULL)
            {
            LocalFree(vhReservedSpace);
            vhReservedSpace = NULL;
            }

        PreloadSaveSegs();  /* Advance loading of code to avoid disk swaps */

        CmdXfSave(psz, pdod->fFormatted, pdod->fBackup, vhcIBeam);

        if (vfDiskFull || vfSysFull)
            ferror = FALSE;
#if defined(OLE)
        else
            ObjSavedDoc();
#endif

        if ((vhReservedSpace = LocalAlloc( LHND, cbReserve )) == NULL)
        /* we were unable to re-establish our block of reserved space. */
            Error(IDPMTNoMemory);

        vfCloseFilesInDialog = FALSE;
        }
}


fnSaveAs()
{   /* Entry point for the "Save As..." command */
extern int vfCloseFilesInDialog;
extern int vfOutOfMemory;
extern HANDLE vhReservedSpace;

    if (!CanReadEveryFile((**((**hpdocdod)[docCur].hszFile))))
        return;

    vfCloseFilesInDialog = TRUE;

    /* Close all files on removable media so changing disks is safe */
    CloseEveryRfn( TRUE );

    /* Free the reserved block, to give us memory for the save dialog box
       and for CmdXfSave */
    if (vhReservedSpace != NULL)
        {
        LocalFree(vhReservedSpace);
        vhReservedSpace = NULL;
        }

    PreloadSaveSegs();  /* Advance loading of code to avoid disk swaps */

    DoFileSaveAs();

     if ((vhReservedSpace = LocalAlloc( LHND, cbReserve )) == NULL)
        {   /* Either we were unable to bring up the save dialog
               box, or we were unable to re-establish our
               block of reserved space. */

#if WINVER >= 0x300
                    WinFailure();
#else
                    Error(IDPMTNoMemory);
#endif
        }

    UpdateInvalid();    /* Assure screen gets updated */

    vfCloseFilesInDialog = FALSE;
}


DoFileSaveAs(void)
{
    /* This routine handles input to the Save dialog box. */
    static CHAR szDefault[ cchMaxFile ];
    extern int vfTextOnlySave;
    extern DoSaveAsFilenameGet(LPSTR,LPSTR,int *,int *,int * ,int *);
    BOOL bDontDelPictures=FALSE;
    int fWordFmt, fTextOnly, fBackup, fOldWrite;
    CHAR szFullNameNewDoc[ cchMaxFile ];      // full name of selection
    CHAR szShortNameNewDoc[ cchMaxFile ];      // file name of selection
    CHAR szDocName[ cchMaxFile ];   // file name of current
    #define szFullNameCurDoc (**((**hpdocdod)[docCur].hszFile))  // full name of current
    #define pDod  ((struct DOD *)&(**hpdocdod)[docCur])

    {
        int cch = 0;
        CHAR szDOSPath[ cchMaxFile ];
        if (FNormSzFile( szDOSPath, "", dtyNormal ))
        {
            if ((cch=CchSz( szDOSPath )-2) > 2)
            {
                Assert( szDOSPath[ cch ] == '\\');
                szDOSPath [cch] = '\0';
            }

#if 0
            if (cch > 3)
                szDOSPath [cch] = '\\';
#endif
        }
        else
            szDOSPath[0] = '\0';

        if (szFullNameCurDoc [0] != '\0')
        {       /* Set default string for filename edit area */
            CHAR szDocPath[ cchMaxFile ];   // path to current

            FreezeHp();
            SplitSzFilename( szFullNameCurDoc, szDocPath, szDocName );

            /* Default filename does not include the document's path if
                it is == the current directory path */
            if (WCompSz( szDOSPath, szDocPath ) == 0)
                bltsz(szDocName, szDefault);
            else
                bltsz(szFullNameCurDoc, szDefault);

            MeltHp();
        }
        else
        {
            szDefault[0] = szDocName[0] = '\0';
        }
    }

    fTextOnly = vfTextOnlySave;
    fBackup = vfBackupSave;
    fWordFmt = vWordFmtMode & ~CONVFROMWORD;
    fOldWrite = vfOldWriteFmt;

    EnableOtherModeless(FALSE);

    while(1)
    {
    if (!DoSaveAsFilenameGet(szDefault,szFullNameNewDoc,&fBackup,&fTextOnly,&fWordFmt,&fOldWrite))
        goto end;
    else
    {
        int dty;

        if (szFullNameNewDoc[0] == '\0')
            goto end;

        if (fOldWrite || fWordFmt || fTextOnly)
        {
            if (!WannaDeletePictures(docCur,fOldWrite ? SF_OLDWRITE : SF_WORD))
                continue;
        }

        StartLongOp();

        szFileExtract(szFullNameNewDoc, szShortNameNewDoc);

#ifdef INTL /* International version */
        /* Read the "Microsoft Word Format" button */

        /* vWordFmtMode is used in WriteFn. If true, will convert
            to Word format, if false, no conversion is done.
            Another value, CONVFROMWORD, can be given during an open
            to allow saving a Word document in Write format. */

        if (fWordFmt)
        /* if set, make the default extension be doc instead of
            wri for word docs */

            dty = dtyWordDoc;
        else
#endif  /* International version */

        dty = dtyNormal;

#if WINVER >= 0x300            
/* Currently: FNormSzFile  *TAKES*   an OEM sz, and
                        *RETURNS*  an ANSI sz ..pault */
#endif
        if ( pDod->fReadOnly &&
                WCompSz( szFullNameNewDoc, szFullNameCurDoc ) == 0)
            {   /* Must save read-only file under a different name */
            Error( IDPMTReadOnly );
            goto NSerious;  /* Error not serious, stay in dialog */
            }
#if WINVER >= 0x300
        else if (WCompSz(szFullNameCurDoc, szFullNameNewDoc) == 0 &&
                    vWordFmtMode == CONVFROMWORD &&
                    vfTextOnlySave == fTextOnly)
            /* User has loaded a text file and is going
                to save under the same name without changing
                formats, *OR* has loaded a Word document and
                is going to save in the same format -- don't
                prompt "replace file?" ..pault 1/17/90 */
            ;
#endif
        else if ((WCompSz(szFullNameCurDoc, szFullNameNewDoc) != 0
#ifdef INTL /* International version */
                /* vWordFmtMode hasn't be reset yet */
                || ( vWordFmtMode == CONVFROMWORD)
#endif  /* International version */
                )
                && FExistsSzFile( dtyNormal, szFullNameNewDoc ) )
        {
            /* User changed the default string and specified
                a filename for which the file already exists.
                Or, we did a Word format conversion, forcing the .WRI
                extension on the file, and a file with that name
                exists.(International version only).o

                Note that vfWordFmtMode will be set to True or False
                below, so this check is made only on the first save
                after a Word conversion.

                Prompt to make sure it's ok to trash the existing one */

            CHAR szFileUp[ cchMaxFile  ];
            CHAR szUserOEM[cchMaxFile]; /* ..converted to OEM */
            CHAR szT[ cchMaxSz ];

            CchCopyUpperSz( szShortNameNewDoc, szFileUp );
            MergeStrings (IDSTRReplaceFile, szFileUp, szT);

#if WINVER >= 0x300
            /* access() expects OEM! */
            AnsiToOem((LPSTR) szFullNameNewDoc, (LPSTR) szUserOEM);

            /* Make sure we don't let someone try to save to 
                a file to which we do not have r/w permission */
            Diag(CommSzNum("fnSaveAs: access(write_perm)==", access(szUserOEM, WRITE_PERMISSION)));
            Diag(CommSzNum("          szExists()==", FExistsSzFile( dtyNormal, szFullNameNewDoc )));
            if (access(szUserOEM, WRITE_PERMISSION) == -1)
                {
                /* THIS COULD BE A CASE OF WRITING TO A FILE
                    WITH R/O ATTRIBUTE, *OR* A SHARING ERROR!
                    IMPROVE ERROR MESSAGE HERE ..pault 11/2/89 */                                
                //Error( IDPMTSDE2 );
                Error( IDPMTReadOnly );
                goto NSerious;  /* Error not serious, stay in dialog */
                }
#endif
            }

            vfTextOnlySave = fTextOnly;
            vfBackupSave = fBackup;
            vfOldWriteFmt = fOldWrite;

#ifdef INTL /* International version */
        /* vWordFmtMode is used in WriteFn. If true, will convert
            to Word format, if false, no conversion is done.
            Another value, CONVFROMWORD, can be given during an open
            to allow saving a Word document in Write format. */

            vWordFmtMode = fWordFmt;

#endif  /* International version */

        /* Record whether a backup was made or not. */

        WriteProfileString( (LPSTR)szWriteProduct, (LPSTR)szBackup,
                vfBackupSave ? (LPSTR)"1" : (LPSTR)"0" );

        /* Save the document */

        CmdXfSave( szFullNameNewDoc,!vfTextOnlySave, vfBackupSave, vhcArrow);

        if (vfDiskFull || vfSysFull)
            goto NSerious;

        /* Case 1: Serious error. Leave the dialog. */
        if (vfDiskError)
        {
            EndLongOp( vhcArrow );
            goto end;
        }

        /* Case 2: Saved OK: set the new title, leave the dialog. */
        else if (!WCompSz( szFullNameNewDoc, szFullNameCurDoc ))
            {
#if defined(OLE)
            ObjRenamedDoc(szFullNameNewDoc);
            ObjSavedDoc();
#endif

            SetTitle(szShortNameNewDoc);
#if WINVER >= 0x300
            FreeUnreferencedFns();
#endif

            /* Update the fReadOnly attribute (9.10.91) v-dougk */
            pDod->fReadOnly = FALSE; // can't be readonly if just saved

            EndLongOp( vhcArrow );
            goto end;
            }

        /* Case 3: Nonserious error (disk full, bad path, etc.).
                stay in dialog. */
        else
            {
NSerious:
            ferror = FALSE;
            EndLongOp( vhcArrow );
StayInDialog:
            CloseEveryRfn( TRUE );
            }
    }
    } // end of while(1)


    end:
    EnableOtherModeless(FALSE);


} /* end of DoFileSaveAs */


#ifdef INTL /* International version */

BOOL far PASCAL DialogWordCvt( hDlg, code, wParam, lParam )
HWND    hDlg;           /* Handle to the dialog box */
unsigned code;
WORD wParam;
LONG lParam;
{

    /* This routine handles input to the Convert From Word Format dialog box. */

 switch (code) {

 case WM_INITDIALOG:
     {
     char szFileDescrip[cchMaxSz];
     char szPrompt[cchMaxSz];

       /* do not allow no convert for formatted file */
     if (fOpenedFormatted)
         {
         //EnableWindow(GetDlgItem(hDlg, idiNo), false);
         PchFillPchId(szFileDescrip, IDSTRConvertWord, sizeof(szFileDescrip));
         }
     else
         PchFillPchId(szFileDescrip, IDSTRConvertText, sizeof(szFileDescrip));
         
     MergeStrings(IDPMTConvert, szFileDescrip, szPrompt);
     SetDlgItemText(hDlg, idiConvertPrompt, (LPSTR)szPrompt);
     EnableOtherModeless(FALSE);
     break;
     }

 case WM_SETVISIBLE:
    if (wParam)
        EndLongOp(vhcArrow);
    return(FALSE);

 case WM_ACTIVATE:
    if (wParam)
        vhWndMsgBoxParent = hDlg;
    if (vfCursorVisible)
        ShowCursor(wParam);
    return(FALSE); /* so that we leave the activate message to the dialog
              manager to take care of setting the focus correctly */

 case WM_COMMAND:
    switch (wParam) {

              /* return one of these values:
                 idiOk - convert
                 idiCancel - cancel, no conversion
                 idiNo - read in without conversion */

        case idiNo: /* User hit the "No Conversion" button */
            if (!IsWindowEnabled(GetDlgItem(hDlg, idiNo)))
        /* No convert is grayed -- ignore */
                return(TRUE);
             /* fall in */
    case idiOk:     /* User hit the "Convert" button */
    case idiCancel:
            break;
    default:
            return(FALSE);
    }
      /* here after ok, cancel, no */
     OurEndDialog(hDlg, wParam);
     break;

 default:
    return(FALSE);
 }
 return(TRUE);
} /* end of DialogWordCvt */

/* International version */
#else
BOOL far PASCAL DialogWordCvt( hDlg, code, wParam, lParam )
HWND    hDlg;           /* Handle to the dialog box */
unsigned code;
WORD wParam;
LONG lParam;
{
    Assert(FALSE);
} /* end of DialogWordCvt */
#endif /* Non Iternational version */




IdConfirmDirty()
{   /* Put up a message box saying docCur "Has changed. Save changes?
       Yes/No/Cancel". Return IDYES, IDNO, or IDCANCEL. */
 extern HWND vhWnd;
 extern CHAR szUntitled[];
 extern HANDLE   hszDirtyDoc;
 LPSTR szTmp = MAKELP(hszDirtyDoc,0);
 CHAR szPath[ cchMaxFile ];
 CHAR szName[ cchMaxFile ];
 CHAR szMsg[ cchMaxSz ];
 CHAR (**hszFile)[]=(**hpdocdod)[docCur].hszFile;

 if ((**hszFile)[0] == '\0')
    CchCopySz( szUntitled, szName );
 else
    SplitSzFilename( *hszFile, szPath, szName );

 wsprintf(szMsg,szTmp,(LPSTR)szName);

 return IdPromptBoxSz( vhWnd, szMsg, MB_YESNOCANCEL | MB_ICONEXCLAMATION );
}




SplitSzFilename( szFile, szPath, szName )
CHAR *szFile;
CHAR *szPath;
CHAR *szName;
{   /* Split a normalized filename into path and bare name components.
       By the rules of normalized filenames, the path will have a drive
       letter, and the name will have an extension. If the name is null,
       we provide the default DOS path and a null szName */

 szPath [0] = '\0';
 szName [0] = '\0';

 if (szFile[0] == '\0')
    {
#if WINVER >= 0x300
    /* Currently: FNormSzFile  *TAKES*   an OEM sz, and
                              *RETURNS*  an ANSI sz ..pault */
#endif
    FNormSzFile( szPath, "", dtyNormal ); /* Use default DOS drive & path */
    }
 else
    {
    CHAR *pch;
    int cch;

    lstrcpy(szPath,(LPSTR)szFile);

    pch = szPath + lstrlen(szPath) - 1; // point to last character

#ifdef	DBCS
    while (pch != szPath) {
        CHAR    *szptr;
        szptr = (CHAR near *)AnsiPrev(szPath,pch);
        if (*szptr == '\\')
            break;
        else
                pch = szptr;
    }
#else   /* DBCS */
    while (pch != szPath)
        if (*(pch-1) == '\\')
            break;
        else
            --pch;

#endif

    lstrcpy(szName,(LPSTR)pch);

#ifdef DBCS
#if !defined(TAIWAN) &&  !defined(PRC)
    pch=(CHAR near *)AnsiPrev(szPath,pch);
    *pch = '\0';
#endif
#else
    *(pch-1) = '\0';
#endif

    }
}


BOOL CheckEnableButton(hCtlEdit, hCtlEnable)
HANDLE hCtlEdit;   /* handle to edit item */
HANDLE hCtlEnable; /* handle to control which is to enable or disable */
{
register BOOL fEnable = SendMessage(hCtlEdit, WM_GETTEXTLENGTH, 0, 0L);

    EnableWindow(hCtlEnable, fEnable);
    return(fEnable);
} /* end of CheckEnableButton */




/***        FDeleteFn - Delete a file
 *
 *
 *
 */

int FDeleteFn(fn)
int fn;
{   /* Delete a file & free its fn slot */
    /* Returns TRUE if the file was successfully deleted or if it was not
       found in the first place; FALSE if the file exists but
       cannot be deleted */

int f = FALSE;

if (FEnsureOnLineFn( fn ))  /* Ensure disk w/ file is in drive */
    {
    CloseFn( fn );  /* Ensure file closed */

    f = FDeleteFile( &(**(**hpfnfcb) [fn].hszFile) [0] );
    }

FreeFn( fn );   /* We free the fn even if the file delete failed */

return f;
}



FDeleteFile( szFileName )
CHAR szFileName[];
{   /* Delete szFilename. Return TRUE if the file was deleted,
       or there was no file by that name; FALSE otherwise.
       Before deleting the file, we ask all other WRITE instances whether
       they need it; if one does, we do not delete and return FALSE */

HANDLE HszGlobalCreate( CHAR * );
int fpe=0;
int fOk;
ATOM a;

if ((a = GlobalAddAtom( szFileName )) != NULL)
    {
    fOk = WBroadcastMsg( wWndMsgDeleteFile, a, (LONG) 0, FALSE );
    if (fOk)
    {   /* Ok to delete, no other instance needs it */
    fpe = FpeDeleteSzFfname( szFileName );
    }
#ifdef DEBUG
     else
     Assert( !FIsErrFpe( fpe ) );
#endif
    GlobalDeleteAtom( a );
    }

    /* OK if: (1) Deleted OK  (2) Error was "File not found" */
return (!FIsErrFpe(fpe)) || fpe == fpeFnfError;
}




FDeleteFileMessage( a )
ATOM a;
{   /* We are being notified that the file hName is being deleted.
       a is a global atom.  (Was global handle before fixing for NT 3.5)
       Return TRUE = Ok to delete; FALSE = Don't delete, this instance
        needs the file */

 LPCH lpch;
 CHAR sz[ cchMaxFile ];

 Scribble( 5, 'D' );

 if (GlobalGetAtomName( a, sz, sizeof(sz)) != 0)
    {
    if (FnFromSz( sz ) != fnNil)
       {
       Scribble( 4, 'F' );
       return FALSE;
       }
    }

 Scribble( 4, 'T' );
 return TRUE;
}




/***        FpeRenameFile - rename a file
 *
 */

int FpeRenameFile(szFileCur, szFileNew) /* Both filenames expected in ANSI */
CHAR *szFileCur, *szFileNew;
{
   /* Rename a file.  Return fpeNoErr if successful; error code if not. */
int fn = FnFromSz( szFileCur );
int fpe;
CHAR (**hsz)[];
HANDLE hName;
HANDLE hNewName;

#if WINVER >= 0x300
/* The szPathName field in rgbOpenFileBuf is now treated as OEM
   as opposed to ANSI, so we must do a conversion.  12/5/89..pault */
CHAR szFileOem[cchMaxFile];
AnsiToOem((LPSTR)szFileNew, (LPSTR)szFileOem);
#define sz4OpenFile szFileOem
#else
#define sz4OpenFile szFileNew
#endif

/* If this is a file we know about, try to make sure it's on line */

if (fn != fnNil)
    if (FEnsureOnLineFn( fn ))
    {
    FFlushFn( fn ); /* just in case */
    CloseFn( fn );
    }
    else
    return fpeHardError;

/* if the file exists on disk then try to rename it */
if (szFileCur[0] != 0 && FExistsSzFile(dtyAny, szFileCur))
    {
    int fpe=FpeRenameSzFfname( szFileCur, szFileNew );

    if ( FIsErrFpe( fpe ) )
        /* Rename failed -- return error code */
        return fpe;
    }
else
    return fpeNoErr;

    /* Inform other instances of WRITE */
if ((hName = HszGlobalCreate( szFileCur )) != NULL)
    {
    if ((hNewName = HszGlobalCreate( szFileNew )) != NULL)
    {
    WBroadcastMsg( wWndMsgRenameFile, hName, (LONG)hNewName, -1 );
    GlobalFree( hNewName );
    }
    GlobalFree( hName );
    }

if (fn != fnNil)
    { /* Rename current FCB for file if there is one */
    struct FCB *pfcb;

    FreeH((**hpfnfcb)[fn].hszFile);
    hsz = HszCreate((PCH)szFileNew);
    pfcb = &(**hpfnfcb) [fn];
    pfcb->hszFile = hsz;

    bltbyte( sz4OpenFile, ((POFSTRUCT)pfcb->rgbOpenFileBuf)->szPathName,
         umin( CchSz( sz4OpenFile ), cchMaxFile ) );

#ifdef DFILE
CommSzSz("FpeRenameFile  szFileNew==",szFileNew);
CommSzSz("               szFileCur==",szFileCur);
CommSzSz("               szFileNewOem==",szFileOem);
#endif

#ifdef ENABLE
    pfcb->fOpened = FALSE;  /* Signal OpenFile that it must open
                   from scratch, not OF_REOPEN */
#endif
    }

return fpeNoErr;
}




RenameFileMessage( hName, hNewName )
HANDLE hName;
HANDLE hNewName;
{   /* We are being notified by another instance of WRITE that the name
       of file hName is being changed to hNewName.  hName and hNewName
       are WINDOWS global handles */

 LPCH lpchName;
 LPCH lpchNewName;

 Scribble( 5, 'R' );
 Scribble( 4, ' ' );

 if ((lpchName = GlobalLock( hName )) != NULL)
    {
    if ((lpchNewName = GlobalLock( hNewName )) != NULL)
    {
    CHAR (**hsz) [];
    CHAR szName[ cchMaxFile ];
    CHAR szNewName[ cchMaxFile ];
    int fn;

    bltszx( lpchName, (LPCH) szName );
    bltszx( lpchNewName, (LPCH) szNewName );

    if ((fn=FnFromSz( szName )) != fnNil &&
        !FNoHeap(hsz = HszCreate( szNewName )))
        {
#if WINVER >= 0x300
        /* The szPathName field in rgbOpenFileBuf is now treated as OEM
           as opposed to ANSI, so we must do a conversion.  12/5/89..pault */
        CHAR szNewOem[cchMaxFile];
        AnsiToOem((LPSTR)szNewName, (LPSTR)szNewOem);
        bltsz( szNewOem, ((POFSTRUCT)((**hpfnfcb) [fn].rgbOpenFileBuf))->szPathName );
#else
        bltsz( szNewName, ((POFSTRUCT)((**hpfnfcb) [fn].rgbOpenFileBuf))->szPathName );
#endif

#ifdef ENABLE
        (**hpfnfcb) [fn].fOpened = FALSE;
#endif
        FreeH( (**hpfnfcb) [fn].hszFile );
        (**hpfnfcb) [fn].hszFile = hsz;
        }
    GlobalUnlock( hNewName );
    }
    GlobalUnlock( hName );
    }
}




#ifdef DEBUG
#define STATIC
#else
#define STATIC static
#endif

STATIC int messageBR;
STATIC WORD wParamBR;
STATIC LONG lParamBR;
STATIC int wStopBR;

STATIC int wResponseBR;

STATIC FARPROC lpEnumAll=NULL;
STATIC FARPROC lpEnumChild=NULL;


WBroadcastMsg( message, wParam, lParam, wStop )
int message;
WORD wParam;
LONG lParam;
WORD wStop;
{   /* Send a message to the document child windows (MDOC) of all
       currently active instances of WRITE (except ourselves).
       Continue sending until all instances have been notified, or until
       one returns the value wStop as a response to the message.
       Return the response given by the last window notified, or
       -1 if no other instances of WRITE were found */

extern HANDLE hMmwModInstance;
int FAR PASCAL BroadcastAllEnum( HWND, LONG );
int FAR PASCAL BroadcastChildEnum( HWND, LONG );

 messageBR = message;
 wParamBR = wParam;
 lParamBR = lParam;
 wStopBR = wStop;
 wResponseBR = -1;

 if (lpEnumAll == NULL)
    {
    lpEnumAll = MakeProcInstance( (FARPROC) BroadcastAllEnum, hMmwModInstance );
    lpEnumChild = MakeProcInstance( (FARPROC) BroadcastChildEnum, hMmwModInstance );
    }

 EnumWindows( lpEnumAll, (LONG)0 );
 return wResponseBR;
}



int FAR PASCAL BroadcastAllEnum( hwnd, lParam )
HWND hwnd;
LONG lParam;
{   /* If hwnd has the class of a WRITE parent (menu) window, call
       (*lpEnumChild)() for each of its children and return
       the value returned by EnumChildWindows
       If the window does not have the class of a WRITE parent, do nothing
       and return TRUE */
 extern CHAR szParentClass[];
 extern HWND hParentWw;

 if ( (hwnd != hParentWw) && FSameClassHwndSz( hwnd, szParentClass ) )
    return EnumChildWindows( hwnd, lpEnumChild, (LONG) 0 );
 else
    return TRUE;
}



int FAR PASCAL BroadcastChildEnum( hwnd, lParam )
HWND hwnd;
LONG lParam;
{   /* If hwnd is of the same class as a WRITE child (document) window,
       send the message { messageBR, wParamBR, lParamBR } to it, else
       return TRUE;
       If the message is sent, return FALSE if the message return value
       matched wStopBR; TRUE if it did not match.
       Set wMessageBR to the message return value.
    */
 extern CHAR szDocClass[];
 extern HWND vhWnd;

 Assert( hwnd != vhWnd );

 if (FSameClassHwndSz( hwnd, szDocClass ))
    {   /* WRITE DOCUMENT WINDOW: pass message along */
    wResponseBR = SendMessage( hwnd, messageBR, wParamBR, lParamBR );
    return wResponseBR != wStopBR;
    }
 else
    return TRUE;
}



FSameClassHwndSz( hwnd, szClass )
HWND hwnd;
CHAR szClass[];
{   /* Compare the Class name of hWnd with szClass; return TRUE
       if they match, FALSE otherwise. */

#define cchClassMax 40  /* longest class name (for compare purposes) */

 CHAR rgchWndClass[ cchClassMax ];
 int cbCopied;

    /* Count returned by GetClassName does not include terminator */
    /* But, the count passed in to it does. */
 cbCopied = GetClassName( hwnd, (LPSTR) rgchWndClass, cchClassMax ) + 1;
 if (cbCopied <= 1)
    return FALSE;

 rgchWndClass[ cbCopied - 1 ] = '\0';

 return WCompSz( rgchWndClass, szClass ) == 0;
}


FConfirmSave()
{   /* Give the user the opportunity to save docCur, if it is dirty.
       Return 1 - Document Saved OR user elected not to save changes
              OR document was not dirty
          0 - User selected "Cancel" or Error during SAVE */
extern HANDLE hMmwModInstance;
extern HANDLE hParentWw;
extern int vfTextOnlySave, vfBackupSave;
struct DOD *pdod=&(**hpdocdod)[docCur];

#if defined(OLE)
    if (CloseUnfinishedObjects(FALSE) == FALSE)
        return FALSE;
#endif

 if (pdod->fDirty)
    {   /* doc has been edited, offer confirm/save before quitting */
    switch ( IdConfirmDirty() )
    {
    case IDYES:
        {
#if 0
#if defined(OLE)
    if (CloseUnfinishedObjects(TRUE) == FALSE)
        return FALSE;
#endif
#endif

        if ( (**(pdod->hszFile))[0] == '\0' )
        goto SaveAs;

#ifdef INTL /* International version */
         /* if saving after a Word conversion, bring up dialog
        box to allow backup/ rename. */

        else if ( vWordFmtMode == CONVFROMWORD)
        goto SaveAs;
#endif /* International version */

        else if (pdod->fReadOnly)
        {
        extern int ferror;

        /* Read-only doc: tell the user to save under a different name */

        Error( IDPMTReadOnly );
        ferror = FALSE; /* Not really an error */

SaveAs:
        fnSaveAs(); /* Bring up "save as" dialog box */
        pdod = &(**hpdocdod)[docCur];
        if (pdod->fDirty)
            /* Save failed or was aborted */
            return FALSE;
        }
        else
        {
            CmdXfSave( *pdod->hszFile, !vfTextOnlySave, vfBackupSave, vhcArrow);

#if defined(OLE)
            if (!ferror)
                ObjSavedDoc();
#endif
        }
        if (ferror)
            /* Don't quit if we got a disk full error */
            return FALSE;
        }
        break;

    case IDNO:
#if 0
#if defined(OLE)
        if (CloseUnfinishedObjects(FALSE) == FALSE)
            return FALSE;
#endif
#endif
        break;

    case IDCANCEL:
    default:
        return FALSE;
    }
    }
#if 0
#if defined(OLE)
 else /* not dirty */
    if (CloseUnfinishedObjects(FALSE) == FALSE)
        return FALSE;
#endif
#endif

 return TRUE;
}




PreloadSaveSegs()
{
#ifdef GREGC /* kludge to get around the windows kernel bug for now */
    LoadF( PurgeTemps );      /* TRANS4 */
    LoadF( IbpEnsureValid );  /* FILE (includes doslib) */
    LoadF( FnCreateSz );      /* CREATEWW */
    LoadF( ClobberDoc );      /* EDIT */
    LoadF( FNormSzFile );     /* FILEUTIL */
    LoadF( CmdXfSave );   /* TRANS2 */
#endif
}




int CchCopyUpperSz(pch1, pch2)
register PCH pch1;
register PCH pch2;
{
int cch = 0;
while ((*pch2 = ChUpper(*pch1++)) != 0)
    {
#ifdef  DBCS    /* KenjiK '90-11-20 */
        if(IsDBCSLeadByte(*pch2))
        {
                pch2++;
                *pch2 = *pch1++;
                cch++;
        }
#endif
    pch2++;
    cch++;
    }
return cch;
} /* end of  C c h C o p y U p p e r S z  */

#ifdef DBCS     // AnsiNext for near call.
static  char NEAR *MyAnsiNext(char *sz)
{
        if(!*sz)                                return sz;

        sz++;
        if(IsDBCSLeadByte(*sz)) return (sz+1);
        else                                    return sz;
}
#endif

#if 0
/* ** Given filename or partial filename or search spec or partial
      search spec, add appropriate extension. */

/*
   fSearching is true when we want to add \*.DOC to the string -
   i.e., we are seeing if string szEdit is a directory. If the string
   is .. or ends in: or \, we know we have a directory name, not a file
   name, and so add \*.DOC or *.DOC to the string. Otherwise, if
   fSearching is true ans szEdit has no wildcard characters,
   add \*.DOC to the string, even if the string contains a period
   (directories can have extensions). If fSearching is false, we will
   add .DOC to the string if no period is found in the last file/directory
   name.

   Note the implicit assumption here that \ and not / will be used as the
   path character. It is held in the defined variable PATHCHAR, but we
   don't handle DOS setups where the / is path and - is the switch character.
*/

#define PATHCHAR ('\\')

NEAR DlgAddCorrectExtension(szEdit, fSearching)
CHAR    *szEdit;
BOOL    fSearching;
{
    register CHAR *pchLast;
    register CHAR *pchT;
    int ichExt;
    BOOL    fDone = FALSE;
    int     cchEdit;

    pchT = pchLast = (szEdit + (cchEdit = CchSz(szEdit) - 1) - 1);

    /* Is szEdit a drive letter followed by a colon (not a filename) ? */
    if (cchEdit == 2
         && *pchLast == ':')
        /* don't use 0 or will interpret "z:" incorrectly as "z:\" ..pault */
        ichExt = 1;
    /* how about ".." (also not a file name)? */
    else if (cchEdit == 2
         && (*pchLast == '.' && *(pchLast-1) == '.'))
        ichExt = 0;
    else if (*pchLast == PATHCHAR)  /* path character */
    ichExt = 1;
    else
    {
        if (fSearching)
            {
             /* any wild card chars? if so, is really a file name */
            if (FSearchSpec(szEdit))
                return;
            ichExt = 0;
            }
        else
            {
            ichExt = 2;
            for (; pchT > szEdit; pchT--) {
                if (*pchT == '.') {
                return;
                }
                if (*pchT == PATHCHAR) {
                /* path character */
                break;
                }
                }
            }

    }
    if (CchSz(szExtSearch+ichExt) + cchEdit > cchMaxFile)
        Error(IDPMTBadFilename);
    else
#ifdef DBCS
        CchCopySz((szExtSearch+ichExt), AnsiNext(pchLast));
#else
        CchCopySz((szExtSearch+ichExt), (pchLast+1));
#endif
}


/* ** return TRUE iff 0 terminated string contains a '*' or '\' */
BOOL  (NEAR FSearchSpec(sz))
register CHAR *sz;
{

#ifdef DBCS
    for (; *sz;sz=AnsiNext(sz)) {
#else
    for (; *sz;sz++) {
#endif
    if (*sz == '*' || *sz == '?')
        return TRUE;
    }
    return FALSE;
}

#endif

szFileExtract(szNormFileName, szExtFileName)
CHAR *szNormFileName; /* input: normalized file name */
CHAR *szExtFileName;  /* output: simple file name with extension added to */
{
    CHAR *pchLast, *pchT;
#ifdef  DBCS    /* KenjiK(MSKK) '90-11-20 */
        for(pchT=szNormFileName;*pchT;pchT++);
        pchLast = pchT;
        do {
                pchT = AnsiPrev(szNormFileName,pchT);
                if (*pchT == '\\')
                        break;
        } while(pchT > szNormFileName);

#else   /* not DBCS */

    pchLast = pchT = szNormFileName + CchSz(szNormFileName) - 1;

    while (pchT > szNormFileName)
    {
    if (*pchT == '\\')
        break;
    pchT --;
    }
#endif

    bltbyte(pchT + 1, szExtFileName, pchLast - pchT);
    //DlgAddCorrectExtension(szExtFileName, FALSE);
}




#ifdef INTL /* International version */

/* ** return TRUE if file opened is in Microsoft Word format */
BOOL  FInWordFormat(fn)
int fn;
{
register struct FCB *pfcb;
int cchT;
       /* Assumption: this routine has been called after FnOpenSz, which
      has already determined whether the file is formatted,
      and if the pnMac entry was 0, it set pnMac to be the same
      as pnFfntb in the file's fcb. So a Word file is a formatted
      file whose pnMac and pnFfntb are the same.

      We are also pretending that unformatted files are word format files
      so we will bring up a dialog box allowing character set conversion. */

    pfcb = &(**hpfnfcb)[fn];
    if (pfcb->fFormatted == false)  /* unformatted treated as a word file */
    return (true);

    return (pfcb->pnMac == pfcb->pnFfntb);
}
#endif  /* International version */


#ifdef INTL /* International version */
void ConvertFromWord ()
{

    /* vWordFmtMode is used by FnWriteFile to translate the
       Word file character set to ANSI. We leave it set to
       CONVFROMWORD so that the next save can check if there was a
       file with extension of szExtDoc.If there is no such file,
       vWordFmtMode is set to true or false by the save dialog code.

       *** as of 2/14/86, no backup is made, but code in CleanDoc checks for
       vWordFmtMode=CONVFROMWORD, and saves without renaming the word
       file instead of making an optional backup

       *** as of 12/3/89, FreeUnreferencedFns() is removing the
       lock on files not referenced by pieces in any documents, so
       the word doc or text file being converted FROM is not being
       "locked" and another app can grab it!  I'm correcting this
       in FreeUnreferencedFns() ..pault
     */

    extern CHAR szExtDoc[];
    struct DOD *pdod=&(**hpdocdod)[docCur];

    vWordFmtMode = CONVFROMWORD;  /* will stay this value until save */
    vfBackupSave = 1;  /* force next save to default to backing up */
      /* always a formatted save, no backup. */
    CmdXfSave( *pdod->hszFile, true, false, vhcArrow);

#if defined(OLE)
    if (!ferror)
        ObjSavedDoc();
#endif
}
#endif  /* International version */


#ifdef INTL /* International version */
TestWordCvt (fn, hWnd)
int fn;
HWND   hWnd;
{
int wordVal;
#ifndef INEFFLOCKDOWN
FARPROC lpDialogWordCvt = MakeProcInstance(DialogWordCvt, hMmwModInstance);
    if (!lpDialogWordCvt)
        {
        WinFailure();
        return(fFalse);
        }
#endif

/* This routine returns the following values:
-1 means dialog box failed (error already sent)
-2 means cancel without conversion.
FALSE means not a word document.
TRUE means convert this word document.
Its parent may change depending on the caller.
*/

if (!(wordVal = FInWordFormat (fn)))
return (FALSE);   /* not a word doc */

/* in word format - ask for conversion */
/* the cvt to word dialog returns 3 values
  other than -1:
     idiOk - convert
     idiCancel - cancel, no conversion
     idiNo - read in without conversion
     vfBackupSave set to reflect whether backup is made */
  /* Note it is a child of this dialog */

fOpenedFormatted = (**hpfnfcb)[fn].fFormatted;  /* used in dialog func */

#ifdef DBCS             /* was in KKBUGFIX */
// [yutakan:05/17/91] (I don't know why) sometimes hWnd would be invalid.
if (!IsWindow(hWnd))    hWnd = hParentWw;
#endif

if ((wordVal = (OurDialogBox( hMmwModInstance,
    MAKEINTRESOURCE(dlgWordCvt), hWnd,
    lpDialogWordCvt))) == -1)
    {
#if WINVER >= 0x300
    WinFailure();
#else
    Error(IDPMTNoMemory);
#endif
        }

#ifndef INEFFLOCKDOWN
    FreeProcInstance(lpDialogWordCvt);
#endif

      /* return -1 if either out of memory or no conversion desired */
      /* will convert an unformatted file if No is the dialog response */
    switch (wordVal)

        {
        case idiNo: /* User hit the "No Conversion" button */
            return(FALSE);  /* treat as non-word file */
        case idiOk: /* User hit the "Convert" button */
            return(TRUE);

        case idiCancel:
            return (-2);

        case -1:
        default:
            return (-1);
        }

}
#endif  /* Kanji / International version */


/* ********** routines for doing message relocation ******* */

VOID MergeInit()
/* get merge spec, guaranteed to be 2 characters, into variable wMerge */
{
char sz[10];

        PchFillPchId( sz, IDS_MERGE1, sizeof(sz) );
        wMerge = *(unsigned *)sz;
}


BOOL MergeStrings (idSrc, szMerge, szDst)
IDPMT idSrc;
CHAR *szMerge;
CHAR *szDst;
{
/* get message from idSrc. Scan it for merge spec. If found, insert string
   szMerge at that point, then append the rest of the message. NOTE!
   merge spec guaranteed to be 2 characters. wMerge loaded at init by
   MergeInit. Returns true if merge done, false otherwise.
*/

CHAR szSrc[cchMaxSz];
register CHAR *pchSrc;
register CHAR *pchDst;

/* get message from resource file */

    PchFillPchId( szSrc, idSrc, sizeof(szSrc) );
    pchSrc = szSrc;
    pchDst = szDst;

    /* find merge spec if any */

    while (*(unsigned *)pchSrc != wMerge)
    {
    *pchDst++ = *pchSrc;

    /* if we reach the end of string before merge spec, just return false */

    if (!*pchSrc++)
        return FALSE;
    }


     /* if merge spec found, insert szMerge there. (check for null merge str */

     if (szMerge)
     while (*szMerge)
         *pchDst++ = *szMerge++;

    /* jump over merge spec */
     pchSrc++;
     pchSrc++;

     /* append rest of string */

     while (*pchDst++ = *pchSrc++)
     ;
     return TRUE;

}

#include "propdefs.h"
BOOL DocHasPictures(int doc)
{
    extern struct PAP      vpapAbs;
    typeCP cpMac = CpMacText(doc),cpNow;
    for ( cpNow = cp0; cpNow < cpMac; cpNow = vcpLimParaCache )
    {
        CachePara( doc, cpNow );
        if (vpapAbs.fGraphics)
            return TRUE;
    }
    return FALSE;
}

BOOL WannaDeletePictures(int doc, int fWhichFormat)
/* assume if SF_OLDWRITE that vcObjects is set */
{
    CHAR szBuf[cchMaxSz];
    BOOL bDoPrompt;

    if (fWhichFormat == SF_OLDWRITE)
    /* warn that OLE pictures will be deleted */
    {
        if (bDoPrompt = (vcObjects > 0))
            PchFillPchId( szBuf, IDPMTDelObjects, sizeof(szBuf) );
    }
    else if (fWhichFormat == SF_WORD)
    /* warn that all pictures will be deleted */
    {
        if (bDoPrompt = DocHasPictures(docCur))
            PchFillPchId( szBuf, IDPMTDelPicture, sizeof(szBuf) );
    }
    else
        return TRUE;

    if (bDoPrompt)
        return (IdPromptBoxSz( vhWnd, szBuf, MB_YESNO | MB_ICONEXCLAMATION ) == IDYES);
    else
        return TRUE;
}

BOOL NEAR PASCAL CanReadEveryFile(char *szFilename)
{
    extern int fnMac;
    int fn;
    BOOL bRetval=TRUE;

    FreezeHp();
    for (fn = 0; fn < fnMac; fn++)
    {
        if ((**hpfnfcb)[fn].fDisableRead)
        {
            /* see if still can't read */
            if (!FAccessFn( fn, dtyNormal ))
            {
                char szMsg[cchMaxSz];
                ferror = FALSE;
                MergeStrings (IDPMTCantRead, szFilename, szMsg);
                IdPromptBoxSz(vhWndMsgBoxParent ? vhWndMsgBoxParent : hParentWw,
                                szMsg, MB_OK | MB_ICONEXCLAMATION | MB_APPLMODAL);
                {
                    bRetval = FALSE;
                    break;
                }
            }
        }
    }

    MeltHp();
    return bRetval;
}