/************************************************************/ /* 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 #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; }