You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
419 lines
8.2 KiB
419 lines
8.2 KiB
/************************************************************/
|
|
/* Windows Write, Copyright 1985-1992 Microsoft Corporation */
|
|
/************************************************************/
|
|
|
|
/* util2.c -- less frequently used utility routines */
|
|
#define NOVIRTUALKEYCODES
|
|
#define NOCTLMGR
|
|
#define NOWINMESSAGES
|
|
#define NOWINSTYLES
|
|
#define NOCLIPBOARD
|
|
#define NOGDICAPMASKS
|
|
#define NOSYSMETRICS
|
|
#define NOMENUS
|
|
#define NOCOMM
|
|
#define NOSOUND
|
|
#include <windows.h>
|
|
|
|
#include "mw.h"
|
|
#include "doslib.h"
|
|
#include "str.h"
|
|
#include "machdefs.h"
|
|
#include "cmddefs.h"
|
|
#include "propdefs.h"
|
|
#include "fkpdefs.h"
|
|
#include "docdefs.h"
|
|
#include "debug.h"
|
|
#include "editdefs.h"
|
|
#include "wwdefs.h"
|
|
#define NOKCCODES
|
|
#include "ch.h"
|
|
|
|
extern struct DOD (**hpdocdod)[];
|
|
extern HANDLE hMmwModInstance;
|
|
extern CHAR vchDecimal; /* "decimal point" character */
|
|
extern int viDigits;
|
|
extern BOOL vbLZero;
|
|
CHAR *PchFillPchId(PCH, int, int);
|
|
|
|
|
|
|
|
FillStId(st, idpmt, cchIn)
|
|
CHAR *st;
|
|
IDPMT idpmt;
|
|
int cchIn;
|
|
{ /* load string from resource file to buffer, the string is zero
|
|
terminated, make it into a st, i.e. cch (excluding '\0' is stored
|
|
in the 1st byte of the string) */
|
|
|
|
int cch = LoadString(hMmwModInstance, idpmt, (LPSTR)&st[1], cchIn-1);
|
|
Assert(cch != 0);
|
|
st[0] = cch;
|
|
} /* FillStId */
|
|
|
|
|
|
CHAR *PchFillPchId(sz, idstr, cchIn)
|
|
register CHAR * sz;
|
|
register int idstr;
|
|
int cchIn;
|
|
{ /*
|
|
Description: load string from resource file to buffer, the
|
|
string loaded is zero terminated
|
|
Returns: pointer to '\0' last loaded
|
|
*/
|
|
int cch = LoadString(hMmwModInstance, idstr, (LPSTR)sz, cchIn);
|
|
/* Note: cch does not include the '\0' */
|
|
{
|
|
char msg[80];
|
|
if (cch == 0)
|
|
{
|
|
wsprintf(msg,"bad resource id: 0x%x\n\r",idstr);
|
|
OutputDebugString(msg);
|
|
}
|
|
Assert(cch != 0);
|
|
}
|
|
return(sz + cch);
|
|
} /* end of PchFillPchId */
|
|
|
|
|
|
int FDirtyDoc(doc)
|
|
register int doc;
|
|
{ /* Return true if killing this doc would lose editing */
|
|
register struct DOD *pdod;
|
|
return ((pdod = &(**hpdocdod)[doc])->fDirty && pdod->cref == 1);
|
|
} /* end of F D i r t y D o c */
|
|
|
|
|
|
int ncvtu(n, ppch)
|
|
register int n;
|
|
CHAR **ppch;
|
|
{
|
|
register int cch = 0;
|
|
|
|
if (n < 0)
|
|
{
|
|
*(*ppch)++ = '-';
|
|
n = -n;
|
|
++cch;
|
|
}
|
|
|
|
if (n >= 10)
|
|
{
|
|
cch += ncvtu(n / 10, ppch);
|
|
n %= 10;
|
|
}
|
|
else if ((n == 0) && !vbLZero) // then no leading zero
|
|
return 0;
|
|
|
|
*(*ppch)++ = '0' + n;
|
|
return cch + 1;
|
|
} /* end of n c v t uR */
|
|
|
|
|
|
HANDLE HszGlobalCreate( sz )
|
|
CHAR *sz;
|
|
{ /* Create handle for string in global windows heap. return the handle. */
|
|
HANDLE h;
|
|
LPCH lpch;
|
|
int cch=CchSz( sz );
|
|
|
|
if ((h=GlobalAlloc( GMEM_MOVEABLE, (LONG)cch )) != NULL)
|
|
{
|
|
if ((lpch = GlobalLock( h )) != NULL )
|
|
{
|
|
bltbx( (LPSTR) sz, lpch, cch );
|
|
GlobalUnlock( h );
|
|
}
|
|
else
|
|
{
|
|
GlobalFree( h );
|
|
return NULL;
|
|
}
|
|
}
|
|
return h;
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
fnScribble( dchPos, ch )
|
|
int dchPos;
|
|
CHAR ch;
|
|
{ /* Scribble a char dchPos char positions from the UR screen corner */
|
|
/* We create a special device context to avoid interfering with the */
|
|
/* ones MEMO uses */
|
|
extern struct WWD rgwwd[];
|
|
|
|
static unsigned dxpScribbleChar=0;
|
|
static unsigned dypScribbleChar;
|
|
static unsigned ypScribble;
|
|
|
|
int xp = wwdCurrentDoc.xpMac - (dxpScribbleChar * (dchPos+1));
|
|
int ilevel = SaveDC( wwdCurrentDoc.hDC );
|
|
|
|
SelectObject( wwdCurrentDoc.hDC, GetStockObject(ANSI_FIXED_FONT) );
|
|
|
|
if ( dxpScribbleChar == 0 )
|
|
{ /* First time through */
|
|
TEXTMETRIC tm;
|
|
|
|
GetTextMetrics( wwdCurrentDoc.hDC, (LPTEXTMETRIC)&tm );
|
|
dxpScribbleChar = tm.tmAveCharWidth;
|
|
dypScribbleChar = tm.tmHeight + tm.tmInternalLeading;
|
|
ypScribble = (dypScribbleChar >> 2) + wwdCurrentDoc.ypMin;
|
|
}
|
|
PatBlt( wwdCurrentDoc.hDC, xp, ypScribble, dxpScribbleChar, dypScribbleChar,
|
|
WHITENESS );
|
|
TextOut( wwdCurrentDoc.hDC, xp, ypScribble, (LPSTR) &ch, 1 );
|
|
RestoreDC( wwdCurrentDoc.hDC, ilevel );
|
|
}
|
|
#endif /* DEBUG */
|
|
|
|
|
|
/* original util3.c starts from here */
|
|
|
|
#define iMaxOver10 3276
|
|
extern int utCur;
|
|
|
|
/* Must agree with cmddefs.h */
|
|
extern CHAR *mputsz[];
|
|
|
|
/* Must agree with cmddefs.h */
|
|
unsigned mputczaUt[utMax] =
|
|
{
|
|
czaInch, czaCm, czaP10, czaP12, czaPoint,
|
|
czaLine
|
|
};
|
|
|
|
|
|
|
|
int FZaFromSs(pza, ss, cch, ut)
|
|
int *pza;
|
|
CHAR ss[];
|
|
int cch,
|
|
ut;
|
|
{ /* Return za in *pza from string representation in ss. True if valid za */
|
|
long lza = 0;
|
|
register CHAR *pch = ss;
|
|
register CHAR *pchMac = &ss[cch];
|
|
int ch;
|
|
unsigned czaUt;
|
|
int fNeg;
|
|
|
|
if (cch <= 0)
|
|
return false;
|
|
|
|
switch (*--pchMac)
|
|
{ /* Check for units */
|
|
case 'n': /* inch */
|
|
if (*--pchMac != 'i')
|
|
goto NoUnits;
|
|
case '"': /* inch */
|
|
ut = utInch;
|
|
break;
|
|
|
|
#ifdef CASHMERE /* units such as pt, pt12, pt10 */
|
|
case '0': /* pt10 */
|
|
if (*--pchMac != '1' || *--pchMac != 'p')
|
|
goto NoUnits;
|
|
ut = utP10;
|
|
break;
|
|
case '2': /* pt12 */
|
|
if (*--pchMac != '1' || *--pchMac != 'p')
|
|
goto NoUnits;
|
|
ut = utP12;
|
|
break;
|
|
case 'i': /* line */
|
|
if (*--pchMac != 'l')
|
|
goto NoUnits;
|
|
ut = utLine;
|
|
break;
|
|
case 't': /* pt */
|
|
if (*--pchMac != 'p')
|
|
goto NoUnits;
|
|
ut = utPoint;
|
|
break;
|
|
#endif /* CASHMERE */
|
|
|
|
case 'm': /* cm */
|
|
if (*--pchMac != 'c')
|
|
goto NoUnits;
|
|
ut = utCm;
|
|
break;
|
|
default:
|
|
++pchMac;
|
|
break;
|
|
NoUnits:
|
|
pchMac = &ss[cch];
|
|
}
|
|
|
|
while (pch < pchMac && *(pchMac - 1) == chSpace)
|
|
--pchMac;
|
|
|
|
czaUt = mputczaUt[ut];
|
|
|
|
/* extract leading blanks */
|
|
while (*pch == ' ')
|
|
pch++;
|
|
|
|
fNeg = *pch == '-';
|
|
if (fNeg) ++pch; /* skip past minus sign */
|
|
while ((ch = *pch++) != vchDecimal)
|
|
{
|
|
if ((ch < '0' || ch > '9') || lza >= iMaxOver10)
|
|
return false;
|
|
lza = lza * 10 + (ch - '0') * czaUt;
|
|
if (pch >= pchMac)
|
|
goto GotNum;
|
|
}
|
|
|
|
while (pch < pchMac)
|
|
{
|
|
ch = *pch++;
|
|
if (ch < '0' || ch > '9')
|
|
return false;
|
|
lza += ((ch - '0') * czaUt + 5) / 10;
|
|
czaUt = (czaUt + 5) / 10;
|
|
}
|
|
|
|
GotNum:
|
|
if (lza > ((long) (22 * czaInch)))
|
|
return false;
|
|
|
|
*pza = fNeg ? (int) -lza : (int) lza;
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
int
|
|
CchExpZa(ppch, za, ut, cchMax)
|
|
CHAR **ppch;
|
|
int ut, cchMax;
|
|
register int za;
|
|
{ /* Stuff the expansion of linear measure za in unit ut into pch.
|
|
Return # of chars stuffed. Don't exceed cchMax. */
|
|
register int cch = 0;
|
|
unsigned czaUt;
|
|
int zu;
|
|
|
|
/* If not in point mode and even half line, display as half lines v. points */
|
|
if (ut == utPoint && utCur != utPoint &&
|
|
(za / (czaLine / 2) * (czaLine / 2)) == za)
|
|
ut = utLine;
|
|
|
|
|
|
czaUt = mputczaUt[ut];
|
|
if (cchMax < cchMaxNum)
|
|
return 0;
|
|
|
|
if (za < 0)
|
|
{ /* Output minus sign and make positive */
|
|
*(*ppch)++ = '-';
|
|
za = -za;
|
|
cch++;
|
|
}
|
|
|
|
/* round off to two decimal places */
|
|
za += czaUt / 200;
|
|
|
|
zu = za / czaUt; /* Get integral part */
|
|
|
|
cch += ncvtu(zu, ppch); /* Expand integral part */
|
|
|
|
za -= zu * czaUt; /* Retain fraction part */
|
|
|
|
if (((za *= 10) >= czaUt || za * 10 >= czaUt) && (viDigits > 0))
|
|
{ /* Check *10 first because of possible overflow */
|
|
zu = za / czaUt;
|
|
|
|
*(*ppch)++ = vchDecimal;
|
|
cch++;
|
|
|
|
*(*ppch)++ = '0' + zu;
|
|
cch++;
|
|
zu = ((za - zu * czaUt) * 10) / czaUt;
|
|
if ((zu != 0) && (viDigits > 1))
|
|
{
|
|
*(*ppch)++ = '0' + zu;
|
|
cch++;
|
|
}
|
|
}
|
|
|
|
if (cch <= 1)
|
|
/* force zeroes */
|
|
{
|
|
if ((cch == 0) && vbLZero) // then no leading zero
|
|
{
|
|
*(*ppch)++ = '0';
|
|
cch++;
|
|
}
|
|
*(*ppch)++ = vchDecimal;
|
|
cch++;
|
|
if (viDigits > 0)
|
|
{
|
|
*(*ppch)++ = '0';
|
|
cch++;
|
|
}
|
|
if (viDigits > 1)
|
|
{
|
|
*(*ppch)++ = '0';
|
|
cch++;
|
|
}
|
|
}
|
|
|
|
cch += CchStuff(ppch, mputsz[ut], cchMax - cch);
|
|
|
|
return cch;
|
|
}
|
|
|
|
|
|
#ifdef KEEPALL /* Use FPdxaFromItDxa2Id */
|
|
int DxaFromSt(st, ut)
|
|
register CHAR *st;
|
|
int ut;
|
|
{
|
|
int za;
|
|
|
|
if (*st > 0 && FZaFromSs(&za, st+1, *st, ut)) /* see util.c */
|
|
return za;
|
|
else
|
|
return valNil;
|
|
}
|
|
|
|
int DxaFromItem(it)
|
|
int it;
|
|
{
|
|
int za;
|
|
register CHAR stBuf[32];
|
|
|
|
GetItTextValue(it, stBuf);
|
|
|
|
if (*stBuf > 0 && FZaFromSs(&za, stBuf+1, *stBuf, utCur)) /* see util.c */
|
|
return (za == valNil) ? 0 : za;
|
|
else
|
|
return valNil;
|
|
}
|
|
#endif
|
|
|
|
int CchStuff(ppch, sz, cchMax)
|
|
CHAR **ppch, sz[];
|
|
int cchMax;
|
|
{
|
|
register int cch = 0;
|
|
register CHAR *pch = *ppch;
|
|
|
|
while (cchMax-- > 0 && (*pch = *sz++) != 0)
|
|
{
|
|
cch++;
|
|
pch++;
|
|
}
|
|
|
|
if (cchMax < 0)
|
|
bltbyte("...", pch - 3, 3);
|
|
|
|
*ppch = pch;
|
|
return cch;
|
|
}
|
|
|