987 lines
31 KiB
C
987 lines
31 KiB
C
/************************************************************/
|
||
/* Windows Write, Copyright 1985-1992 Microsoft Corporation */
|
||
/************************************************************/
|
||
|
||
/* initialization codes for internal memory, page buffers, etc. */
|
||
#define NOKEYSTATE
|
||
#define NOCLIPBOARD
|
||
#define NOGDICAPMASKS
|
||
#define NOCTLMGR
|
||
#define NOVIRTUALKEYCODES
|
||
#define NOWINMESSAGES
|
||
#define NOSYSMETRICS
|
||
#define NOSYSCOMMANDS
|
||
#define NOCOLOR
|
||
#define NOCREATESTRUCT
|
||
#define NOCTLMGR
|
||
#define NODRAWTEXT
|
||
#define NOSHOWWINDOW
|
||
//#define NOATOM
|
||
#define NOMENUS
|
||
#define NOICON
|
||
#define NOKEYSTATE
|
||
#define NOSHOWWINDOW
|
||
#define NOBITMAP
|
||
#define NOSOUND
|
||
#define NOCOMM
|
||
#define NOOPENFILE
|
||
#define NORESOURCE
|
||
#define NOMETAFILE
|
||
#define NOPEN
|
||
#define NOREGION
|
||
#define NOSCROLL
|
||
#define NOWH
|
||
#define NOWINOFFSETS
|
||
/* need gdi, hdc, memmgr */
|
||
#include <windows.h>
|
||
|
||
#include "mw.h"
|
||
#define NOUAC
|
||
#include "cmddefs.h"
|
||
#include "wwdefs.h"
|
||
#include "docdefs.h"
|
||
#include "editdefs.h"
|
||
#include "propdefs.h"
|
||
#include "fmtdefs.h"
|
||
#include "filedefs.h"
|
||
#include "fkpdefs.h"
|
||
#include "stcdefs.h"
|
||
#ifdef CASHMERE
|
||
#include "txb.h"
|
||
#endif /* CASHMERE */
|
||
#include "fontdefs.h"
|
||
#include "code.h"
|
||
#include "heapdefs.h"
|
||
#include "heapdata.h"
|
||
#include "str.h"
|
||
#include "ch.h"
|
||
#if defined(OLE)
|
||
#include "obj.h"
|
||
#endif
|
||
|
||
#ifdef DEBUG
|
||
#define STATIC
|
||
#else
|
||
#define STATIC static
|
||
#endif
|
||
|
||
/* E X T E R N A L S */
|
||
extern int ypMaxWwInit;
|
||
extern int dypWwInit;
|
||
extern int *memory;
|
||
extern int *pmemMax;
|
||
extern CHAR *pmemStart;
|
||
extern unsigned vcbMemTotal;
|
||
extern HWND hParentWw;
|
||
extern HDC vhDCPrinter;
|
||
extern int rfnMac;
|
||
extern CHAR (*rgbp)[cbSector];
|
||
extern int fnMac;
|
||
extern typeTS tsMruRfn;
|
||
extern struct ERFN dnrfn[];
|
||
extern CHAR *rgibpHash;
|
||
extern struct BPS *mpibpbps;
|
||
extern typeTS tsMruBps;
|
||
extern struct CHP vchpNormal;
|
||
extern struct PAP *vppapNormal;
|
||
extern struct SEP vsepNormal;
|
||
extern struct CHP (**vhgchpFormat)[];
|
||
extern int ichpMacFormat;
|
||
extern struct CHP vchpInsert;
|
||
extern struct CHP vchpSel;
|
||
extern struct FCB (**hpfnfcb)[];
|
||
extern struct FKPD vfkpdCharIns;
|
||
extern struct FKPD vfkpdParaIns;
|
||
extern struct PAP vpapPrevIns;
|
||
extern struct FLI vfli;
|
||
extern int docMac;
|
||
extern struct DOD (**hpdocdod)[];
|
||
extern int docScrap;
|
||
extern int docUndo;
|
||
#ifdef CASHMERE /* No docBuffer in WRITE */
|
||
extern int docBuffer;
|
||
#endif
|
||
extern int docCur;
|
||
extern CHAR (**hszSearch)[];
|
||
extern CHAR (**hszReplace)[];
|
||
extern CHAR (**hszFlatSearch)[];
|
||
extern CHAR stBuf[];
|
||
extern int vrefSystem;
|
||
extern CHAR (**vhrgbSave)[];
|
||
extern int vdxaPaper;
|
||
extern int vdyaPaper;
|
||
extern struct SEL selCur;
|
||
extern BOOL vfPrinterValid;
|
||
extern int dxaPrPage;
|
||
extern int dyaPrPage;
|
||
extern int dxpPrPage;
|
||
extern int dypPrPage;
|
||
extern int dxaPrOffset;
|
||
extern int dyaPrOffset;
|
||
extern HCURSOR vhcArrow;
|
||
#ifdef UNUSED
|
||
extern int vfCanPrint;
|
||
#endif
|
||
|
||
//Win3.1J
|
||
#if defined(JAPAN) & defined(DBCS_IME) /* Doc for Insert IR_STRING from IME */
|
||
extern int docIRString;
|
||
#endif
|
||
|
||
/* G L O B A L S -- used only in here */
|
||
int rgwPapNormal[cwPAPBase + cwTBD] = {0};
|
||
|
||
|
||
#ifdef STATICPAGES
|
||
#ifdef MACHA
|
||
#define ibpMaxStatic 79
|
||
#define iibpHashMaxStatic 163
|
||
#else /* not MACHA */
|
||
#define ibpMaxStatic 7
|
||
#define iibpHashMaxStatic 17
|
||
#endif /* MACHA */
|
||
CHAR rgbpStatic[ibpMaxStatic][cbSector];
|
||
#endif /* STATICPAGES */
|
||
|
||
extern typePN PnAlloc();
|
||
|
||
STATIC int NEAR FInitDocs( void );
|
||
STATIC int NEAR FInitProps( void );
|
||
STATIC int NEAR FInitFiles( void );
|
||
WORD wWinVer,fPrintOnly=FALSE;
|
||
|
||
int FInitMemory()
|
||
{
|
||
extern HANDLE vhReservedSpace;
|
||
int i;
|
||
|
||
#ifdef UNUSED
|
||
/* Initially assume that it is not possible to print */
|
||
/* Formerly InitPrint was called here */
|
||
vfCanPrint = false;
|
||
#endif
|
||
|
||
/** This is a glitch so that the fixed array for storing relocation
|
||
information will be created immediately */
|
||
wWinVer = (WORD)(GetVersion() & 0x0000FFFFL);
|
||
if (((wWinVer & 0xFF) >= 3) && ((wWinVer & 0xFF00) >= 0x0A00))
|
||
/* Windows Version >= 3.10 */
|
||
{
|
||
FARPROC LHandleDelta = GetProcAddress(GetModuleHandle((LPSTR)"KERNEL"),(LPSTR)0x136L);
|
||
i = LHandleDelta(0);
|
||
LHandleDelta(i*5); /* make a big finger table */
|
||
vhReservedSpace = LocalAlloc(LHND, cbReserve);
|
||
LocalFree(vhReservedSpace);
|
||
LHandleDelta(i); /* resume to a smaller finger table if needed more */
|
||
}
|
||
else
|
||
/* Windows Version < 3.10 */
|
||
{
|
||
/**
|
||
This is heaping kludge upon kludge in the effort to be backwards
|
||
compatible with past kludges. This is the old macro which with
|
||
Win31 has become a function call. (3.11.91) D. Kent
|
||
**/
|
||
#define LocalHandleDelta(d) ((d) ? (*(pLocalHeap+9) = (d)) : *(pLocalHeap+9))
|
||
i = LocalHandleDelta(0);
|
||
LocalHandleDelta(i*5); /* make a big finger table */
|
||
vhReservedSpace = LocalAlloc(LHND, cbReserve);
|
||
LocalFree(vhReservedSpace);
|
||
LocalHandleDelta(i); /* resume to a smaller finger table if needed more */
|
||
}
|
||
|
||
#ifdef OURHEAP
|
||
/* reserve 1K for windows's memory manager for creating dialog boxes */
|
||
vhReservedSpace = LocalAlloc(LPTR, cbReserve);
|
||
|
||
CreateHeapI(); /* create heap first */
|
||
if (!FCreateRgbp()) /* rgbp are expandable */
|
||
return FALSE;
|
||
|
||
/* now free the reserved space after our memory is set up. */
|
||
/* hopefully we will get all the fixed objects created by
|
||
dialog manager be placed above our memory chunk, so we can still
|
||
expand our heap while a dialog box is up. */
|
||
LocalFree(vhReservedSpace);
|
||
#else
|
||
if (!FCreateRgbp())
|
||
return FALSE;
|
||
vhReservedSpace = LocalAlloc(LHND, cbReserve); /* this is to make
|
||
discardable when we are out of memory and try to bring up the
|
||
save dialog box */
|
||
#endif
|
||
|
||
if (vhReservedSpace == NULL)
|
||
return FALSE;
|
||
|
||
/* formerly CreateHpfnfcb */
|
||
hpfnfcb = (struct FCB (**)[])HAllocate(cwFCB * fnMax);
|
||
if (FNoHeap(hpfnfcb))
|
||
return FALSE;
|
||
fnMac = fnMax;
|
||
for (i = 0; i < fnMac; i++)
|
||
(**hpfnfcb)[i].rfn = rfnFree;
|
||
/* end of CreateHpfnfcb */
|
||
|
||
if (!FSetScreenConstants())
|
||
return FALSE;
|
||
|
||
if ( !FInitDocs() ||
|
||
#ifdef CASHMERE /* No glossary in MEMO */
|
||
!FInitBufs() ||
|
||
#endif /* CASHMERE */
|
||
!FInitProps() ||
|
||
!FInitFiles() )
|
||
return FALSE;
|
||
|
||
/* allocate emergency space for save operations */
|
||
if (FNoHeap(vhrgbSave = (CHAR (**)[])HAllocate(cwSaveAlloc)))
|
||
return FALSE;
|
||
|
||
return TRUE;
|
||
}
|
||
/* end of F I n i t M e m o r y */
|
||
|
||
|
||
|
||
|
||
int FInitArgs(sz)
|
||
CHAR *sz;
|
||
{ /* Set extern int docCur to be a new doc, containing
|
||
the file (if any) specified on the command line (sz).
|
||
|
||
Initialize a wwd (window descriptor) structure for the document
|
||
and set an appropriate title into the title bar.
|
||
|
||
Set selCur to be an insertion point before the first char of the doc,
|
||
and set vchpSel to be the char properties of the insertion point.
|
||
|
||
Return TRUE if all is well, FALSE if something went wrong.
|
||
A return of FALSE means that initialization should not continue.
|
||
*/
|
||
|
||
extern typeCP cpMinDocument;
|
||
extern struct WWD rgwwd[];
|
||
extern int vfDiskError;
|
||
extern int vfSysFull;
|
||
extern int ferror;
|
||
extern BOOL vfWarnMargins;
|
||
|
||
int fn, doc;
|
||
RECT rcCont;
|
||
CHAR szT [ cchMaxFile ];
|
||
register CHAR *pch;
|
||
CHAR ch;
|
||
int fEmptyLine = TRUE;
|
||
CHAR (**hsz) [];
|
||
int iT, cbsz;
|
||
|
||
#ifdef INTL /* International version */
|
||
int fWordDoc = FALSE;
|
||
#endif /* International version */
|
||
|
||
/* Decide whether we have anything but white space on the command line */
|
||
|
||
for ( pch = sz; (ch = *pch) != '\0'; pch++ )
|
||
if ((ch != ' ') && (ch != '\011'))
|
||
{
|
||
fEmptyLine = FALSE;
|
||
break;
|
||
}
|
||
|
||
if (fEmptyLine)
|
||
/* No filename; start with (Untitled) */
|
||
goto Untitled;
|
||
|
||
cbsz = CchSz (sz ) - 1;
|
||
/* remove trailing spaces from sz */
|
||
for ( pch = sz + cbsz - 1; pch >= sz; pch-- )
|
||
if (*pch != ' ')
|
||
break;
|
||
else
|
||
{
|
||
*pch = '\0'; /* replace with null */
|
||
cbsz--;
|
||
}
|
||
|
||
/* check for /p option (6.26.91) v-dougk */
|
||
if ((sz[0] == '/') && (sz[1] == 'p'))
|
||
{
|
||
sz += 2;
|
||
cbsz -= 2;
|
||
fPrintOnly = TRUE;
|
||
for (; *sz; sz++, cbsz-- ) // get to filename
|
||
if ((*sz != ' ') && (*sz != '\011'))
|
||
break;
|
||
|
||
if (!*sz) /* No filename, abort */
|
||
return FALSE;
|
||
}
|
||
|
||
/* convert to OEM */
|
||
AnsiToOem(sz, sz);
|
||
|
||
if (!FValidFile( sz, cbsz, &iT ) ||
|
||
!FNormSzFile( szT, sz, dtyNormal ))
|
||
{ /* Bad filename -- it could not be normalized */
|
||
extern int vfInitializing;
|
||
char szMsg[cchMaxSz];
|
||
char *pch;
|
||
extern HWND vhWndMsgBoxParent;
|
||
extern HANDLE hParentWw;
|
||
|
||
vfInitializing = FALSE; /* Do not suppress reporting this err */
|
||
MergeStrings (IDPMTBadFileName, sz, szMsg);
|
||
/* if we're being called from a message box, then use it
|
||
as the parent window, otherwise use main write window */
|
||
IdPromptBoxSz(vhWndMsgBoxParent ? vhWndMsgBoxParent : hParentWw,
|
||
szMsg, MB_OK | MB_ICONEXCLAMATION | MB_APPLMODAL);
|
||
ferror = TRUE; /* need to flag */
|
||
vfInitializing = TRUE;
|
||
goto Untitled;
|
||
}
|
||
|
||
if ((fn = FnOpenSz( szT, dtyNormal,
|
||
index( szT, '/' ) == NULL &&
|
||
index( szT,':') == NULL && index( szT, '\\') == NULL )) != fnNil)
|
||
/* Opened file OK -- prefetch file contents into rgbp */
|
||
{
|
||
|
||
#ifdef INTL /* Kanji / 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)
|
||
or cancel without conversion.
|
||
FALSE means not a word document.
|
||
TRUE means convert this word document.
|
||
vfBackupSave is changed to reflect whether
|
||
save is done with backup.
|
||
*/
|
||
|
||
#ifdef KKBUGFIX // added by Hiraisi (BUG#2816 WIN31) in Japan
|
||
if ((fWordDoc = TestWordCvt (fn, (HWND)NULL)) == -1 ||
|
||
fWordDoc == -2)
|
||
#else
|
||
if ((fWordDoc = TestWordCvt (fn, (HWND)NULL)) == -1)
|
||
#endif
|
||
goto Untitled;
|
||
/* if fWordDoc is true, will convert later */
|
||
#endif /* International version */
|
||
|
||
|
||
StartLongOp();
|
||
ReadFilePages( fn );
|
||
EndLongOp(vhcArrow);
|
||
}
|
||
else /* Could not open file */
|
||
{
|
||
if (fPrintOnly)
|
||
return FALSE;
|
||
else
|
||
{ /* use (Untitled) */
|
||
Untitled:
|
||
fn = fnNil;
|
||
sz [0] = '\0';
|
||
szT [0] = '\0';
|
||
}
|
||
}
|
||
|
||
if (vfDiskError || vfSysFull)
|
||
/* Serious disk error OR disk holding scratch file is full --
|
||
bail out */
|
||
return FALSE;
|
||
|
||
if (fn != fnNil)
|
||
{ /* Opened file OK -- must account for the case when OpenFile
|
||
returned a filename that differed from the one given it */
|
||
|
||
bltsz( &(**(**hpfnfcb) [fn].hszFile) [0], szT );
|
||
}
|
||
|
||
if (FNoHeap(hsz=HszCreate( (PCH) szT )) ||
|
||
(doc=DocCreate( fn, hsz, dtyNormal )) == docNil)
|
||
{ /* Could not create a doc */
|
||
return FALSE;
|
||
}
|
||
if (WwNew(doc, dypWwInit, ypMaxWwInit) == wwNil)
|
||
return FALSE;
|
||
NewCurWw(0, true);
|
||
if (fn != fnNil)
|
||
{
|
||
vfWarnMargins = TRUE;
|
||
SetPageSize();
|
||
vfWarnMargins = FALSE;
|
||
}
|
||
wwdCurrentDoc.cpFirst = selCur.cpLim = selCur.cpFirst = cpMinDocument;
|
||
selCur.fForward = true;
|
||
GetInsPtProps(selCur.cpFirst);
|
||
|
||
#ifdef OURHEAP
|
||
{
|
||
extern int cwInitStorage;
|
||
/* save this amount of heap as "100% free" */
|
||
/* formerly CalcTot(true) */
|
||
cwInitStorage = cwHeapMac - cwHeapFree;
|
||
cbTot = (cwHeapMac - cwInitStorage) * sizeof(int);
|
||
cbTotQuotient = (cbTot>>1)/100;
|
||
}
|
||
#endif
|
||
|
||
#ifdef STYLES
|
||
/* Set up scrap document to have a valid style sheet on start up. */
|
||
(**hpdocdod)[docScrap].docSsht = (**hpdocdod)[docCur].docSsht;
|
||
#endif /* STYLES */
|
||
|
||
#ifdef INTL /* International version */
|
||
/* if a word document to be converted, save
|
||
it doing conversion. */
|
||
|
||
if (fWordDoc == TRUE)
|
||
{
|
||
/* save file in write format. */
|
||
ConvertFromWord();
|
||
}
|
||
#endif /* International version */
|
||
|
||
SetTitle(szT);
|
||
|
||
#if defined(OLE)
|
||
ObjOpenedDoc(doc);
|
||
#endif
|
||
return TRUE;
|
||
}
|
||
/* end of F I n i t A r g s */
|
||
|
||
|
||
|
||
|
||
#ifdef OURHEAP
|
||
CreateHeapI()
|
||
{
|
||
FGR *pfgr, *pfgrLim;
|
||
#ifdef WINBUG
|
||
unsigned cb = (unsigned)GlobalCompact((DWORD)0);
|
||
#endif
|
||
|
||
ibpMax = ibpMaxSmall;
|
||
if (cb > 0x4fff /* about 20K */)
|
||
{
|
||
HANDLE hTemp;
|
||
/* we can start with a bigger page buffer */
|
||
vcbMemTotal = (unsigned)LocalCompact((WORD)0);
|
||
pmemStart = (CHAR *)LocalAlloc(LPTR, vcbMemTotal);
|
||
/* get all we have and force a reallocation */
|
||
hTemp = LocalReAlloc((HANDLE)pmemStart, 0x4fff, LPTR);
|
||
if (hTemp != NULL)
|
||
{
|
||
LocalFree(hTemp);
|
||
ibpMax = ibpMaxBig;
|
||
}
|
||
else
|
||
{
|
||
/* somehow we failed and went back to the small system */
|
||
LocalFree((HANDLE)pmemStart);
|
||
}
|
||
}
|
||
|
||
vcbMemTotal = (unsigned)LocalCompact((WORD)0);
|
||
|
||
/* memory always bumped to point to the next available slot
|
||
for allocation */
|
||
/* take all the space as one chunk and do our own memory management */
|
||
pmemStart = (CHAR *)LocalAlloc(LPTR, vcbMemTotal);
|
||
memory = (int *)pmemStart;
|
||
vcbMemTotal = (unsigned)LocalSize((HANDLE)pmemStart); /* in case
|
||
we got more than we asked */
|
||
pmemMax = (int *)((CHAR *)memory + vcbMemTotal);
|
||
|
||
/* take half of heap space for page buffers
|
||
ibpMax = (vcbMemTotal>>1)/cbSector;*/
|
||
iibpHashMax = ibpMax * 2 + 1;
|
||
|
||
/* Set finger table to low end of heap */
|
||
rgfgr = (PFGR)memory;
|
||
memory += ifgrInit;
|
||
memory = (int *)(((unsigned) memory + 1) & ~1); /* word boundary */
|
||
|
||
/* Here is our heap */
|
||
pHeapFirst = (int *)memory;
|
||
|
||
cwHeapMac = /* cwtotal */
|
||
(((unsigned)pmemMax - (unsigned)pHeapFirst +
|
||
sizeof(int) - 1) / sizeof(int)) -
|
||
/* cw in rgibpHash */
|
||
((iibpHashMax * sizeof(CHAR) +
|
||
sizeof(int) - 1) / sizeof(int)) -
|
||
/* cw in mpibpbps */
|
||
((ibpMax * sizeof(struct BPS) +
|
||
sizeof(int) - 1) / sizeof(int)) -
|
||
/* cw in rgbp */
|
||
((ibpMax * cbSector * sizeof(CHAR) +
|
||
sizeof(int) - 1) / sizeof(int));
|
||
|
||
memory += cwHeapMac;
|
||
|
||
#ifdef DEBUG
|
||
cwHeapMac -= 16; /* Need spare words for shaking */
|
||
/* This space is above the finger table */
|
||
#endif
|
||
cwHeapFree = cwHeapMac;
|
||
phhMac = (HH *)(pHeapFirst + cwHeapMac);
|
||
/* if DEBUG, then phhMac will point at the shake word;
|
||
otherwise it will point to 1 cell after the heap */
|
||
|
||
phhFree = (HH *) pHeapFirst;
|
||
phhFree->cw = -cwHeapMac; /* whobj.heap is free */
|
||
phhFree->phhNext = phhFree;
|
||
phhFree->phhPrev = phhFree;
|
||
|
||
pfgrMac = &rgfgr[ifgrInit];
|
||
pfgrLim = pfgrMac - 1;
|
||
|
||
/* thread the free fingers */
|
||
for (pfgr = rgfgr; pfgr < pfgrLim; pfgr++)
|
||
*pfgr = (FGR)(pfgr + 1);
|
||
*pfgrLim = NULL; /* last free finger */
|
||
pfgrFree = rgfgr;
|
||
}
|
||
/* end of C r e a t e H e a p I */
|
||
#endif /* OURHEAP */
|
||
|
||
|
||
|
||
STATIC int NEAR FInitDocs()
|
||
{ /* Initialize hpdocdod */
|
||
struct DOD *pdod, *pdodLim;
|
||
hpdocdod = (struct DOD (**)[])HAllocate(cwDOD * (docMac = cdocInit));
|
||
if (FNoHeap(hpdocdod))
|
||
return FALSE;
|
||
|
||
pdod = &(**hpdocdod)[0];
|
||
pdodLim = pdod + cdocInit;
|
||
while (pdod < pdodLim)
|
||
pdod++->hpctb = 0; /* Mark all doc entries as free */
|
||
docScrap = DocCreate(fnNil, HszCreate((PCH)""), dtyBuffer); /* HM */
|
||
|
||
//Win3.1J
|
||
#if defined(JAPAN) & defined(DBCS_IME) /* Doc for Insert IR_STRING from IME */
|
||
docIRString = DocCreate(fnNil, HszCreate((PCH)""), dtyBuffer); /* HM */
|
||
#endif
|
||
|
||
docUndo = DocCreate(fnNil, HszCreate((PCH)""), dtyBuffer); /* HM */
|
||
#ifdef CASHMERE
|
||
docBuffer = DocCreate(fnNil, HszCreate((PCH)""), dtyBuffer); /* HM */
|
||
#endif
|
||
|
||
docCur = docNil;
|
||
NoUndo();
|
||
hszSearch = HszCreate((PCH)""); /* No initial search string */
|
||
hszReplace = HszCreate((PCH)""); /* No initial replace string */
|
||
hszFlatSearch = HszCreate((PCH)""); /* No initial flattenned search string */
|
||
if (docScrap == docNil || docUndo == docNil ||
|
||
#if defined(JAPAN) & defined(DBCS_IME) /* Doc for Insert IR_STRING from IME */
|
||
docIRString == docNil ||
|
||
#endif
|
||
#ifdef CASHMERE
|
||
docBuffer == docNil ||
|
||
#endif
|
||
FNoHeap(hszFlatSearch))
|
||
return FALSE;
|
||
return TRUE;
|
||
}
|
||
/* end of F I n i t D o c s */
|
||
|
||
|
||
|
||
|
||
#ifdef CASHMERE /* No glossary in MEMO */
|
||
FInitBufs()
|
||
{
|
||
/* Initializes structures and data used in named buffer management.
|
||
Allocates space for hgtxb, initializes itxbMac */
|
||
|
||
struct TXB *ptxb;
|
||
extern struct TXB (**hgtxb)[];
|
||
extern short itxbMac;
|
||
|
||
if (FNoHeap(hszGlosFile = HszCreate((PCH)"")))
|
||
return FALSE;
|
||
if (FNoHeap(hgtxb = (struct TXB (**)[])HAllocate(cwTxb)))
|
||
return FALSE;
|
||
ptxb = &(**hgtxb)[0];
|
||
ptxb->hszName = hszNil;
|
||
itxbMac = 0;
|
||
return TRUE;
|
||
}
|
||
/* end of F I n i t B u f s */
|
||
#endif /* CASHMERE */
|
||
|
||
|
||
|
||
STATIC int NEAR FInitProps()
|
||
{ /* Initialize your basic properties */
|
||
|
||
#ifndef FIXED_PAGE
|
||
unsigned dxaRightMin;
|
||
unsigned dyaBottomMin;
|
||
#endif /* not FIXED_PAGE */
|
||
|
||
vchpNormal.hps = hpsNormal; /* NOTE - this is the size we use for
|
||
incremental encoding, the "default"
|
||
size may differ */
|
||
vchpNormal.ftc = 0; /* will be whatever the standard modern font is */
|
||
vchpNormal.ftcXtra = 0;
|
||
|
||
vchpNormal.fStyled = true;
|
||
/* vchpNormal.stc = stcNormal; */
|
||
|
||
vppapNormal = (struct PAP *)rgwPapNormal;
|
||
|
||
/* vppapNormal->fStyled = false; */
|
||
/* vppapNormal->stc = 0; */
|
||
vppapNormal->stcNormChp = stcParaMin;
|
||
/* vppapNormal->dxaRight = 0; */
|
||
/* vppapNormal->dxaLeft = 0; */
|
||
/* vppapNormal->dxaLeft1 = 0; */
|
||
/* vppapNormal->jc = jcLeft; */
|
||
/* vppapNormal->dyaBefore = 0; */
|
||
/* vppapNormal->dtaAfter = 0; */
|
||
|
||
vppapNormal->fStyled = true;
|
||
vppapNormal->stc = stcParaMin;
|
||
vppapNormal->dyaLine = czaLine;
|
||
|
||
Assert(cwPAP == cwSEP);
|
||
|
||
/* vsepNormal.fStyled = false; */
|
||
/* vsepNormal.stc = 0; */
|
||
vsepNormal.bkc = bkcPage;
|
||
/* vsepNormal.nfcPgn = nfcArabic; */
|
||
|
||
#ifdef FIXED_PAGE
|
||
/* The "normal" page size is fixed at 8-1/2 by 11 inches. */
|
||
vsepNormal.xaMac = cxaInch * 8 + cxaInch / 2;
|
||
vsepNormal.xaLeft = cxaInch * 1 + cxaInch / 4;
|
||
vsepNormal.dxaText = cxaInch * 6;
|
||
vsepNormal.yaMac = cyaInch * 11;
|
||
vsepNormal.yaTop = cyaInch * 1;
|
||
vsepNormal.dyaText = cyaInch * 9;
|
||
vsepNormal.yaRH1 = cyaInch * 3 / 4;
|
||
vsepNormal.yaRH2 = cyaInch * 10 + cyaInch / 4;
|
||
#else /* not FIXED_PAGE */
|
||
/* The page size is determined by inquiring it from the printer. Then,
|
||
other measurements can be derived from it. */
|
||
Assert(vhDCPrinter);
|
||
if (vfPrinterValid && vhDCPrinter != NULL)
|
||
{
|
||
POINT pt;
|
||
|
||
/* Get the page size of the printer. */
|
||
if (Escape(vhDCPrinter, GETPHYSPAGESIZE, 0, (LPSTR)NULL,
|
||
(LPSTR)&pt))
|
||
{
|
||
vsepNormal.xaMac = MultDiv(pt.x, dxaPrPage, dxpPrPage);
|
||
vsepNormal.yaMac = MultDiv(pt.y, dyaPrPage, dypPrPage);
|
||
}
|
||
else
|
||
{
|
||
/* The printer won't tell us it page size; we'll have to settle
|
||
for the printable area. */
|
||
vsepNormal.xaMac = ZaFromMm(GetDeviceCaps(vhDCPrinter,
|
||
HORZSIZE));
|
||
vsepNormal.yaMac = ZaFromMm(GetDeviceCaps(vhDCPrinter,
|
||
VERTSIZE));
|
||
}
|
||
|
||
/* The page size cannot be smaller than the printable area. */
|
||
if (vsepNormal.xaMac < dxaPrPage)
|
||
{
|
||
vsepNormal.xaMac = dxaPrPage;
|
||
}
|
||
if (vsepNormal.yaMac < dyaPrPage)
|
||
{
|
||
vsepNormal.yaMac = dyaPrPage;
|
||
}
|
||
|
||
/* Determine the offset of the printable area on the page. */
|
||
if (Escape(vhDCPrinter, GETPRINTINGOFFSET, 0, (LPSTR)NULL,
|
||
(LPSTR)&pt))
|
||
{
|
||
dxaPrOffset = MultDiv(pt.x, dxaPrPage, dxpPrPage);
|
||
dyaPrOffset = MultDiv(pt.y, dyaPrPage, dypPrPage);
|
||
}
|
||
else
|
||
{
|
||
/* The printer won't tell us what the offset is; assume the
|
||
printable area is centered on the page. */
|
||
dxaPrOffset = (vsepNormal.xaMac - dxaPrPage) >> 1;
|
||
dyaPrOffset = (vsepNormal.yaMac - dyaPrPage) >> 1;
|
||
}
|
||
|
||
/* Determine the minimum margins. */
|
||
dxaRightMin = imax(0, vsepNormal.xaMac - dxaPrOffset - dxaPrPage);
|
||
dyaBottomMin = imax(0, vsepNormal.yaMac - dyaPrOffset - dyaPrPage);
|
||
}
|
||
else
|
||
{
|
||
/* We have no printer; so, the page is 8-1/2" by 11" for now. */
|
||
vsepNormal.xaMac = 8 * czaInch + czaInch / 2;
|
||
vsepNormal.yaMac = 11 * czaInch;
|
||
|
||
/* Assume the entire page can be printed. */
|
||
dxaPrOffset = dyaPrOffset = dxaRightMin = dyaBottomMin = 0;
|
||
}
|
||
|
||
/* Ensure that the "normal" margins are larger than the minimum. */
|
||
vsepNormal.xaLeft = umax(cxaInch * 1 + cxaInch / 4, dxaPrOffset);
|
||
vsepNormal.dxaText = vsepNormal.xaMac - vsepNormal.xaLeft - umax(cxaInch
|
||
* 1 + cxaInch / 4, dxaRightMin);
|
||
vsepNormal.yaTop = umax(cyaInch * 1, dyaPrOffset);
|
||
vsepNormal.dyaText = vsepNormal.yaMac - vsepNormal.yaTop - umax(cyaInch
|
||
* 1, dyaBottomMin);
|
||
|
||
/* Position the running-heads and the page numbers. */
|
||
vsepNormal.yaRH1 = umax(cyaInch * 3 / 4, dyaPrOffset);
|
||
vsepNormal.yaRH2 = vsepNormal.yaMac - umax(cyaInch * 3 / 4,
|
||
dyaBottomMin);
|
||
vsepNormal.xaPgn = vsepNormal.xaMac - umax(cxaInch * 1 + cxaInch / 4,
|
||
dxaRightMin);
|
||
vsepNormal.yaPgn = umax(cyaInch * 3 / 4, dyaPrOffset);
|
||
#endif /* not FIXED_PAGE */
|
||
|
||
vsepNormal.pgnStart = pgnNil;
|
||
/* vsepNormal.fAutoPgn = false; */
|
||
/* vsepNormal.fEndFtns = false; */
|
||
vsepNormal.cColumns = 1;
|
||
vsepNormal.dxaColumns = cxaInch / 2;
|
||
/* vsepNormal.dxaGutter = 0; */
|
||
|
||
vdxaPaper = vsepNormal.xaMac;
|
||
vdyaPaper = vsepNormal.yaMac;
|
||
|
||
vfli.doc = docNil; /* Invalidate vfli */
|
||
ichpMacFormat = ichpMacInitFormat;
|
||
vhgchpFormat = (struct CHP (**)[])HAllocate(ichpMacInitFormat * cwCHP);
|
||
if (FNoHeap(vhgchpFormat))
|
||
{
|
||
return FALSE;
|
||
}
|
||
return TRUE;
|
||
}
|
||
/* end of F I n i t P r o p s */
|
||
|
||
|
||
|
||
|
||
|
||
STATIC int NEAR FInitFiles()
|
||
{
|
||
extern WORD vwDosVersion;
|
||
|
||
int fn;
|
||
int cchT;
|
||
struct FKP *pfkp;
|
||
struct FCB *pfcb;
|
||
int osfnExtra;
|
||
CHAR sz [cchMaxFile];
|
||
|
||
rfnMac = rfnMacEdit;
|
||
|
||
/* Set DOS version we're running under */
|
||
|
||
vwDosVersion = WDosVersion();
|
||
|
||
InitBps();
|
||
|
||
#ifdef CKSM
|
||
#ifdef DEBUG
|
||
{
|
||
extern int ibpMax, ibpCksmMax;
|
||
extern unsigned (**hpibpcksm) [];
|
||
|
||
hpibpcksm = (unsigned (**) [])HAllocate( ibpMax );
|
||
if (FNoHeap( hpibpcksm ))
|
||
return FALSE;
|
||
ibpCksmMax = ibpMax;
|
||
}
|
||
#endif
|
||
#endif
|
||
|
||
/* sz <-- name of new, unique file which will be fnScratch */
|
||
sz[ 0 ] = '\0'; /* Create it in the root on a temp drive */
|
||
if ((fn=FnCreateSz( sz, cpNil, dtyNetwork )) == fnNil )
|
||
/* Couldn't create scratch file: fail */
|
||
return FALSE;
|
||
|
||
Assert(fn == fnScratch); /* fnScratch hardwired to 0 for efficiency */
|
||
FreezeHp();
|
||
pfcb = &(**hpfnfcb)[fnScratch];
|
||
pfcb->fFormatted = true; /* Sort of a formatted file */
|
||
pfcb->fDelete = true; /* Kill this file when we quit */
|
||
MeltHp();
|
||
vfkpdParaIns.brun = vfkpdCharIns.brun = 0;
|
||
vfkpdParaIns.bchFprop = vfkpdCharIns.bchFprop = cbFkp;
|
||
vfkpdParaIns.pn = PnAlloc(fnScratch);
|
||
((struct FKP *) PchGetPn(fnScratch, vfkpdParaIns.pn, &cchT, true))->fcFirst =
|
||
fc0;
|
||
vfkpdCharIns.pn = PnAlloc(fnScratch);
|
||
((struct FKP *) PchGetPn(fnScratch, vfkpdCharIns.pn, &cchT, true))->fcFirst =
|
||
fc0;
|
||
|
||
/* The following can really be allocated 0 words, but why push our luck? */
|
||
vfkpdParaIns.hgbte = (struct BTE (**)[]) HAllocate(cwBTE);
|
||
vfkpdCharIns.hgbte = (struct BTE (**)[]) HAllocate(cwBTE);
|
||
vfkpdParaIns.ibteMac = vfkpdCharIns.ibteMac = 0;
|
||
if (FNoHeap(vfkpdParaIns.hgbte) || FNoHeap(vfkpdCharIns.hgbte))
|
||
return FALSE;
|
||
|
||
blt(&vchpNormal, &vchpInsert, cwCHP);
|
||
blt(&vchpNormal, &vchpSel, cwCHP);
|
||
blt(vppapNormal, &vpapPrevIns, cwPAPBase + cwTBD);
|
||
return TRUE;
|
||
}
|
||
/* end of F I n i t F i l e s */
|
||
|
||
|
||
|
||
|
||
InitBps()
|
||
{
|
||
/* called from initfiles to set up the tables */
|
||
int ibp, iibp;
|
||
int rfn;
|
||
int fn;
|
||
|
||
/* In order impliment a LRU page swap strategy, a time stamp(TS) scheme is */
|
||
/* used. Associated with each buffer slot is a time stamp. The least */
|
||
/* recently used slot is found by locating the slot with the smallest time */
|
||
/* stamp. Every time a new page is brought into the buffer, it TS is set */
|
||
/* equal to the value of a incrimented global TS counter (tsMru...). */
|
||
/* Initially, the time stamps are set so that they increase as we move */
|
||
/* toward the end of the table. Thus, even though the entire buffer pool */
|
||
/* is initially empty, slots at the beginning of the table will be */
|
||
/* allocated first. */
|
||
|
||
{
|
||
register struct ERFN *perfn = &dnrfn [0];
|
||
|
||
for (rfn = 0; rfn < rfnMac; rfn++, perfn++)
|
||
{
|
||
perfn->fn = fnNil;
|
||
perfn->ts = rfn;
|
||
}
|
||
tsMruRfn = rfnMac /* + ? */;
|
||
}
|
||
|
||
for (iibp = 0; iibp < iibpHashMax; iibp++)
|
||
rgibpHash[iibp] = ibpNil;
|
||
{
|
||
register struct BPS *pbps=&mpibpbps [0];
|
||
|
||
for (ibp = 0; ibp < ibpMax; ++ibp, pbps++)
|
||
{
|
||
pbps->fn = fnNil;
|
||
pbps->fDirty = false;
|
||
pbps->ts = ibp;
|
||
pbps->ibpHashNext = ibpNil;
|
||
}
|
||
tsMruBps = ibpMax + cbpMustKeep;
|
||
}
|
||
/* In IbpEnsureValid (file.c) we may not want to use the least */
|
||
/* recently used slot for certain reasons. But, we do want to */
|
||
/* be assured that we do not clobber the 'cbpMustKeep' most */
|
||
/* recently used slots. Our check consists of making sure */
|
||
/* (tsMruBps - ts_in_question) < cbpMustKeep. By the above */
|
||
/* statement, we are assured that non of the empty slots satisfy */
|
||
/* this condition. */
|
||
|
||
/* Allocate initial checksum array */
|
||
|
||
|
||
|
||
}
|
||
/* end of I n i t B p s */
|
||
|
||
|
||
|
||
#ifdef OURHEAP
|
||
FCreateRgbp()
|
||
{
|
||
rgbp = (CHAR (*)[cbSector])memory;
|
||
memory = (int *)((unsigned)memory + (unsigned)(ibpMax)
|
||
* cbSector);
|
||
memory = (int *)(((unsigned) memory + 1) & ~1); /* word boundary */
|
||
rgibpHash = (CHAR *)memory;
|
||
memory = (int *)((unsigned)memory +
|
||
(unsigned)(iibpHashMax * sizeof(CHAR)));
|
||
memory = (int *)(((unsigned) memory + 1) & ~1); /* word boundary */
|
||
mpibpbps = (struct BPS *)memory;
|
||
memory = (int *)((unsigned)memory +
|
||
(unsigned)(ibpMax * sizeof(struct BPS)));
|
||
memory = (int *)(((unsigned) memory + 1) & ~1);
|
||
return (memory <= pmemMax);
|
||
}
|
||
/* end of F C r e a t e R g b p */
|
||
#else /* use windows' memory manager */
|
||
FCreateRgbp()
|
||
{
|
||
extern int vfLargeSys;
|
||
|
||
long lcbFree;
|
||
unsigned cb;
|
||
|
||
ibpMax = ibpMaxSmall;
|
||
lcbFree = GlobalCompact((DWORD)0);
|
||
if (lcbFree > 0x00030D40 /* 200K */)
|
||
{
|
||
/* we can start with a bigger page buffer */
|
||
ibpMax = ibpMaxBig;
|
||
vfLargeSys = TRUE;
|
||
}
|
||
|
||
iibpHashMax = ibpMax * 2 + 1;
|
||
|
||
cb = ((ibpMax * cbSector * sizeof(CHAR) + 1) & ~1) /* rgbp */
|
||
+ ((iibpHashMax * sizeof(CHAR) + 1) & ~1) /* rgibpHash */
|
||
+ ((ibpMax * sizeof(struct BPS) + 1) & ~1); /* mpibpbps */
|
||
|
||
memory = (int *)LocalAlloc(LPTR, cb);
|
||
|
||
if (memory == NULL)
|
||
{
|
||
ibpMax = ibpMaxSmall;
|
||
iibpHashMax = ibpMax * 2 + 1;
|
||
cb = ((ibpMax * cbSector * sizeof(CHAR) + 1) & ~1) /* rgbp */
|
||
+ ((iibpHashMax * sizeof(CHAR) + 1) & ~1) /* rgibpHash */
|
||
+ ((ibpMax * sizeof(struct BPS) + 1) & ~1); /* mpibpbps */
|
||
memory = (int *)LocalAlloc(LPTR, cb);
|
||
}
|
||
|
||
if (memory == NULL)
|
||
return FALSE;
|
||
|
||
rgbp = (CHAR (*)[cbSector])memory;
|
||
memory = (int *)((unsigned)memory + (unsigned)(ibpMax)
|
||
* cbSector);
|
||
memory = (int *)(((unsigned) memory + 1) & ~1); /* word boundary */
|
||
rgibpHash = (CHAR *)memory;
|
||
memory = (int *)((unsigned)memory +
|
||
(unsigned)(iibpHashMax * sizeof(CHAR)));
|
||
memory = (int *)(((unsigned) memory + 1) & ~1); /* word boundary */
|
||
mpibpbps = (struct BPS *)memory;
|
||
|
||
/*
|
||
memory = (int *)((unsigned)memory +
|
||
(unsigned)(ibpMax * sizeof(struct BPS)));
|
||
memory = (int *)(((unsigned) memory + 1) & ~1);*/
|
||
|
||
return TRUE;
|
||
}
|
||
#endif
|
||
|