able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/mvdm/wow16/write/menu.c

1421 lines
40 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/************************************************************/
/* Windows Write, Copyright 1985-1992 Microsoft Corporation */
/************************************************************/
/* menu.c -- WRITE menu handling routines */
#define NOGDICAPMASKS
#define NOVIRTUALKEYCODES
#define NOWINMESSAGES
#define NOWINSTYLES
#define NOCTLMGR
#define NOSYSMETRICS
#define NOICON
#define NOKEYSTATE
#define NORASTEROPS
#define NOSHOWWINDOW
//#define NOATOM
#define NOCREATESTRUCT
#define NODRAWTEXT
#define NOMETAFILE
#define NOSOUND
#define NOSCROLL
#define NOWH
#define NOOPENFILE
#define NOCOMM
#define NOMSG
#define NOREGION
#define NORECT
#include <windows.h>
#include "mw.h"
#include "cmddefs.h"
#include "filedefs.h"
#include "wwdefs.h"
#include "docdefs.h"
#include "propdefs.h"
#include "prmdefs.h"
#define NOKCCODES
#include "ch.h"
#include "editdefs.h"
#include "menudefs.h"
#include "str.h"
#include "fontdefs.h"
#include "dlgdefs.h"
#include "dispdefs.h"
#include <shellapi.h>
#if defined(OLE)
#include "obj.h"
#endif
#ifdef JAPAN //T-HIROYN Win3.1
#include "kanji.h"
#endif
extern int FAR PASCAL ShellAbout(HWND hWnd, LPSTR szApp, LPSTR szOtherStuff, HICON hIcon);
extern typeCP cpMinCur, cpMacCur;
extern struct WWD rgwwd[];
extern CHAR stBuf[];
extern int docCur;
extern struct DOD (**hpdocdod)[];
extern struct SEL selCur;
extern int vfOutOfMemory;
extern BOOL vfWinFailure;
extern int vfSysFull;
extern int vfDiskError;
extern struct CHP vchpAbs;
extern struct PAP vpapAbs;
extern struct CHP vchpFetch;
extern struct CHP vchpSel;
extern int vfSeeSel;
extern typeCP vcpFetch;
extern int vccpFetch;
extern typeCP cpMacCur;
extern typeCP vcpLimParaCache;
extern HMENU vhMenu; /* global handle to the top level menu */
extern HANDLE hParentWw;
extern HCURSOR vhcHourGlass;
extern HANDLE hMmwModInstance;
extern HANDLE vhDlgFind;
extern HANDLE vhDlgChange;
extern HANDLE vhDlgChange;
extern CHAR (**hszSearch)[]; /* Default search string */
#ifdef CASHMERE
extern int vfVisiMode;
extern HWND vhWndGlos;
extern HWND vhWndScrap;
#endif /* CASHMERE */
#ifdef ONLINEHELP
extern fnHelp(void);
#endif /* ONLINEHELP */
/* These values are comprised of one bit for each menu item in the
applicable menu (for example, there are bitcount(0xfff)==12 menu
items under Character) ..pault */
static int rgmfAllItems[CMENUS] = {
0x01ff, /* FILE */
0x003f, /* EDIT */
0x000f, /* FIND */
#if defined(JAPAN) & defined(IME_HIDDEN) //IME3.1J
0x03ff, /* CHARACTER */
#else
0x01ff, /* CHARACTER */
#endif
0x01ff, /* PARA */
0x001f, /* DOCU */
0x000f /* HELP */
};
/* When we're editing a running header or footer, use this */
static int rgmfRunning[CMENUS] = {
0x0020, /* FILE -- enable printer-setup only */
0x003F, /* EDIT -- everything */
0x0007, /* FIND -- enable find/again and change */
#if defined(JAPAN) & defined(IME_HIDDEN) //IME3.1J
0x03ff, /* CHARACTER -- everything */
#else
0x01FF, /* CHARACTER -- everything */
#endif
0x01FF, /* PARAGRAPH -- everything */
0x001F, /* DOCUMENT -- everything */
0x000f /* HELP -- everything */
};
int viffnMenuMac;
NEAR PutSzUndoInMenu(void);
NEAR GetChpVals (struct CHP *, TSV *);
NEAR GetPapVals (struct PAP *, TSV *);
NEAR GetHffn (struct CHP *, TSV *);
NEAR SetChUndef(TSV *, struct CHP *, int *);
NEAR SetParaUndef(TSV *, struct PAP *, int *);
NEAR FNoSearchStr(HWND);
SetAppMenu(hMenu, index)
HMENU hMenu; /* handle to popup menu */
int index; /* index to popup menu */
{
/* Mark greying and checks on menus as appropriate to current state. */
extern BOOL vfPrinterValid;
extern CHAR (**hszPrPort)[];
extern CHAR szNul[];
extern int vfPictSel;
extern int vfOwnClipboard;
extern int docScrap;
extern struct UAB vuab;
extern HWND vhWnd;
typeCP CpMacText();
register int rgmfT[CMENUS]; /* Our workspace for menu greying */
int imi;
int imiMin = 0;
int imiMax = 0;
int *pflags;
TSV rgtsv[itsvchMax]; /* gets attributes and gray flags from CHP, PAP */
unsigned wPrintBitPos = ~(0x0001 << (imiPrint - imiFileMin));
/* If we are out of memory or the disk is full, then... */
if (vfOutOfMemory || vfSysFull || vfDiskError || vfWinFailure)
{
bltc( rgmfT, 0, CMENUS );
#if WINVER >= 0x300
/* Disable the print stuff, but leave New/Open/Save/SaveAs/Exit */
rgmfT[FILE] = 0x008f;
#else
/* Disable everything except Save & SaveAs */
rgmfT[FILE] = 0x0018;
#endif
}
else
{
/* Start with all items or subset if editing running head/foot */
blt( (wwdCurrentDoc.fEditHeader || wwdCurrentDoc.fEditFooter) ? rgmfRunning
: rgmfAllItems, rgmfT, CMENUS );
#if defined(JAPAN) & defined(IME_HIDDEN) //IME3.1J
{
extern int vfImeHidden; /*T-HIROYN ImeHidden Mode flag*/
if(index == CHARACTER) {
/* Version 3.1 or more ok */
if(FALSE == GetIMEVersioOk(vhWnd)) {
rgmfT[CHARACTER] = 0x1ff; //Set Ime mode memu gray
vfImeHidden = 0;
}
if(TRUE == GetIMEOpenMode(vhWnd))
rgmfT[CHARACTER] = 0x1ff; //Set Ime mode memu gray
}
}
#endif
}
pflags = &rgmfT[index];
switch (index)
{
case FILE:
imiMin = imiFileMin;
imiMax = imiFileMax;
/* Disallow print, if the printer or the port is not valid. */
if (!vfPrinterValid || hszPrPort == NULL ||
WCompSz( *hszPrPort, szNul ) == 0)
*pflags &= wPrintBitPos;
break;
case EDIT:
imiMin = imiEditMin;
imiMax = imiEditMax;
/* Disallow cut, copy if the selection is empty */
if (selCur.cpFirst == selCur.cpLim)
{
*pflags &= 0xfff9;
}
/* Move and Size picture are only allowed if a picture is selected */
if (!vfPictSel)
*pflags &= 0xFFCF;
/* Disallow Paste if we can determine that the scrap is empty.
Regrettably, we can be fooled into thinking it is not by
another instance of MEMO that is the clipboard owner and has
an empty scrap. */
/* Disallow UNDO if appropriate; set UNDO string into menu */
{
if ((vuab.uac == uacNil) || vfOutOfMemory)
{
/* Gray out undo */
*pflags &= 0xfffe;
}
PutSzUndoInMenu();
}
break;
case FIND:
imiMin = imiFindMin;
imiMax = imiFindMax;
if ((GetActiveWindow() == hParentWw && CchSz(**hszSearch) == 1) ||
(!vhDlgFind && !vhDlgChange && (CchSz(**hszSearch) == 1)) ||
(vhDlgFind && FNoSearchStr(vhDlgFind)) ||
(vhDlgChange && FNoSearchStr(vhDlgChange)))
*pflags &= 0xfffd; /* disable find again */
if (CpMacText( docCur ) == cp0)
*pflags &= 0xfff0; /* disable find, search, change, goto page */
break;
case CHARACTER:
imiMin = imiCharMin;
imiMax = imiCharMax;
if (!(vfOutOfMemory || vfWinFailure))
{
int iffn, iffnCurFont, fSetFontList;
struct FFN **hffn, *pffn;
union FCID fcid;
extern struct FFN **MpFcidHffn();
/* GetRgtsvChpSel() fills up rgtsv */
GetRgtsvChpSel(rgtsv);
CheckMenuItem(hMenu, imiBold,
(rgtsv[itsvBold].fGray == 0 && rgtsv[itsvBold].wTsv != 0) ?
MF_CHECKED : MF_UNCHECKED);
CheckMenuItem(hMenu, imiItalic,
(rgtsv[itsvItalic].fGray == 0 && rgtsv[itsvItalic].wTsv != 0) ?
MF_CHECKED : MF_UNCHECKED);
CheckMenuItem(hMenu, imiUnderline,
(rgtsv[itsvUline].fGray == 0 && rgtsv[itsvUline].wTsv != 0) ?
MF_CHECKED : MF_UNCHECKED);
/* note that the value stored in rgtsv[itsvPosition].wTsv
is really a signed integer, so we can just check for
0, > 0, and < 0 */
CheckMenuItem(hMenu, imiSuper,
(rgtsv[itsvPosition].fGray == 0
&& (int)(rgtsv[itsvPosition].wTsv) > 0) ?
MF_CHECKED : MF_UNCHECKED);
CheckMenuItem(hMenu, imiSub,
(rgtsv[itsvPosition].fGray == 0
&& (int)(rgtsv[itsvPosition].wTsv) < 0) ?
MF_CHECKED : MF_UNCHECKED);
#if defined(JAPAN) & defined(IME_HIDDEN) //IME3.1J
//IME3.1J
{
extern int vfImeHidden; /*T-HIROYN ImeHidden Mode flag*/
CheckMenuItem(hMenu, imiImeHidden,
vfImeHidden ? MF_CHECKED : MF_UNCHECKED);
}
#endif
#if 0
/* SetFontMenuItems() pulled on line */
{
/* make sure that the right font names are on the character dropdown */
/* These two lines avoid calculating bdodCur twice */
unsigned int bdodCur = docCur * sizeof (struct DOD);
#define pdodCur ( (struct DOD *) ( (CHAR *)(&(**hpdocdod) [0]) + bdodCur))
fSetFontList = !(*(pdodCur->hffntb))->fFontMenuValid;
if (fSetFontList)
{
/* need to get the current list */
viffnMenuMac = 0;
if (FInitFontEnum(docCur, 3, TRUE))
{
for (iffn = 0; iffn < 3; iffn++)
{
if (!FEnumFont((struct FFN *)rgffnFontMenu[iffn]))
break;
viffnMenuMac++;
}
EndFontEnum();
(*(pdodCur->hffntb))->fFontMenuValid = TRUE;
}
}
/* make sure the current font is on the list - ok, so it's kind of
a hack */
mfFonts = 0xffff; /* template to mask "no font" entries */
iffnCurFont = -1;
hffn = (struct FFN **)rgtsv[itsvFfn].wTsv;
for (iffn = 0; iffn < 3; iffn++)
{
if (iffn >= viffnMenuMac)
mfFonts ^= (0x0040 << iffn); /* disable this entry */
else if (iffnCurFont < 0 && !rgtsv[itsvFfn].fGray)
{
pffn = (struct FFN *)rgffnFontMenu[iffn];
if (WCompSz((*hffn)->szFfn, pffn->szFfn) == 0)
iffnCurFont = iffn;
}
}
if (!rgtsv[itsvFfn].fGray && iffnCurFont < 0)
{
/* no match for this font - ram it in */
if (viffnMenuMac < 3)
viffnMenuMac++;
iffnCurFont = viffnMenuMac - 1;
bltbyte(*hffn, rgffnFontMenu[iffnCurFont],
CbFfn(CchSz((*hffn)->szFfn)));
mfFonts |= (0x0040 << iffnCurFont); /* enable this entry */
/* invalidate cache since we're messing it up */
(*pdodCur->hffntb)->fFontMenuValid = FALSE;
fSetFontList = TRUE;
}
if (fSetFontList)
/* font name cache has changed - update the menu dropdown */
for (iffn = 0; iffn < 3; iffn++)
{
int imi;
#ifdef KOREA
int i;
CHAR rgb[LF_FACESIZE + 8];
#else
CHAR rgb[LF_FACESIZE + 4];
#endif
if (iffn < viffnMenuMac)
{
#ifdef KOREA /* sangl 91.6.19 */
i = CchCopySz(((struct FFN *)rgffnFontMenu [iffn])->szFfn,
&rgb [0]);
rgb[i] = '(';
rgb[i+1] = '\036';
rgb[i+2] = '1' + iffn;
rgb[i+3] = '\037';
rgb[i+4] = '<EFBFBD>';
rgb[i+5] = '<EFBFBD>' + iffn;
rgb[i+6] = ')';
rgb[i+7] = '\0';
#else
rgb[0] = '&';
rgb[1] = '1' + iffn;
rgb[2] = '.';
rgb[3] = ' ';
CchCopySz(((struct FFN *)rgffnFontMenu [iffn])->szFfn,
&rgb [4]);
#endif
}
else
{
/* empty font name -- don't display it */
rgb [0] = '\0';
}
/* Set the menu */
imi = imiFont1 + iffn;
ChangeMenu( vhMenu, imi, (LPSTR)rgb, imi, MF_CHANGE );
}
}
*pflags &= mfFonts;
/* see which (if any) fonts apply */
/* note that the value stored in rgtsv[itsvFfn].wTsv
is the font name handle, rather than the ftc */
for (iffn = 0; iffn < 3; iffn++)
{
CheckMenuItem(hMenu, imiFont1 + iffn,
iffn == iffnCurFont ? MF_CHECKED : MF_UNCHECKED);
}
#endif
}
break;
case PARA:
imiMin = imiParaMin;
imiMax = imiParaMax;
if (!(vfOutOfMemory || vfWinFailure))
{
int jc;
/* GetRgtsvPapSel() fills up rgtsv with paragraph properties */
GetRgtsvPapSel(rgtsv);
/* if gray, set jc to invalid value */
jc = (rgtsv[itsvJust].fGray == 0) ? rgtsv[itsvJust].wTsv : jcNil;
CheckMenuItem(hMenu, imiParaNormal, MF_UNCHECKED);
CheckMenuItem(hMenu, imiLeft, jc == jcLeft ? MF_CHECKED : MF_UNCHECKED);
CheckMenuItem(hMenu, imiCenter, jc == jcCenter ? MF_CHECKED :
MF_UNCHECKED);
CheckMenuItem(hMenu, imiRight, jc == jcRight ? MF_CHECKED :
MF_UNCHECKED);
CheckMenuItem(hMenu, imiJustified, jc == jcBoth ? MF_CHECKED :
MF_UNCHECKED);
CheckMenuItem(hMenu, imiSingleSpace,
(rgtsv[itsvSpacing].fGray == 0
&& rgtsv[itsvSpacing].wTsv == czaLine) ?
MF_CHECKED : MF_UNCHECKED);
CheckMenuItem(hMenu, imiOneandhalfSpace,
(rgtsv[itsvSpacing].fGray == 0
&& rgtsv[itsvSpacing].wTsv == (3 * czaLine / 2)) ?
MF_CHECKED : MF_UNCHECKED);
CheckMenuItem(hMenu, imiDoubleSpace,
(rgtsv[itsvSpacing].fGray == 0
&& rgtsv[itsvSpacing].wTsv == (2 * czaLine)) ?
MF_CHECKED : MF_UNCHECKED);
}
break;
case DIV:
imiMin = imiDocuMin;
imiMax = imiDocuMax;
if (wwdCurrentDoc.fEditHeader)
*pflags &= ~2; /* disable footer */
else if (wwdCurrentDoc.fEditFooter)
*pflags &= ~1; /* disable header */
break;
default:
break;
} /* end of switch */
{ /* enable or gray menu items */
register WORD wFlagMask = 1;
for (imi = imiMin; imi < imiMax; imi++)
{
EnableMenuItem(hMenu, imi, (*pflags & wFlagMask ? MF_ENABLED :
MF_GRAYED));
wFlagMask <<= 1;
}
}
#if defined(OLE)
if (index == EDIT)
ObjUpdateMenu(hMenu);
#endif
}
NEAR PutSzUndoInMenu()
{
/* Put the proper string for the current undo into the EDIT menu.
idstrCurrentUndo gives the resource id for the current undo string. An
idstrCurrentUndo value of -1 means use the last value loaded.
This routine caches Undo strings so resource loads are needed only
when the string changes. */
extern struct UAB vuab;
extern int idstrCurrentUndo; /* Current UNDO's string ID */
extern CHAR szAltBS[];
#ifdef JAPAN //T-HIROYN Win3.1
static CHAR szUndo[ cchSzUndo + 5];
#else
static CHAR szUndo[ cchSzUndo ];
#endif
static int idstrUndoCache = -1;
if (vuab.uac == uacNil)
{
idstrCurrentUndo = IDSTRUndoBase;
}
if (idstrCurrentUndo < 0)
{
/* This means we should use the last Undo string */
Assert(idstrUndoCache > 0);
idstrCurrentUndo = idstrUndoCache;
}
if (idstrCurrentUndo != idstrUndoCache)
{
/* Cached string is no good, build another */
CHAR *PchFillPchId();
CHAR *pch = szUndo;
#if defined(KOREA)
if (idstrCurrentUndo != IDSTRUndoBase)
{
/* need the tail part */
pch = PchFillPchId(pch, idstrCurrentUndo, (int)sizeof(szUndo) );
}
pch += LoadString(hMmwModInstance, IDSTRUndoBase, (LPSTR)pch,
(int)(szUndo + sizeof(szUndo) - pch));
CchCopySz((PCH)szAltBS, pch);
#else
pch += LoadString(hMmwModInstance, IDSTRUndoBase, (LPSTR)szUndo,
cchSzUndo);
if (idstrCurrentUndo != IDSTRUndoBase)
{
/* need the tail part */
pch = PchFillPchId(pch, idstrCurrentUndo,
(int)(szUndo + sizeof(szUndo) - pch));
}
CchCopySz((PCH)szAltBS, pch);
#endif
/* Set the menu */
ChangeMenu( vhMenu, imiUndo, (LPSTR)szUndo, imiUndo, MF_CHANGE );
/* Set cache for next time */
idstrUndoCache = idstrCurrentUndo;
}
}
GetRgtsvChpSel (prgtsv)
TSV *prgtsv;
{
/* Return properties for the character menu. */
typeCP cpLim;
typeCP cpStartRun;
struct CHP chp;
int cchGray = 0; /* number of undefined (grayed) character attributes */
int ccpFetch = 0; /* number of calls made to FetchCp */
/* max number of calls to FetchCp */
#define ccpFetchMax 50
#ifndef SAND
if (selCur.cpLim > cpMacCur)
{
bltbc(prgtsv, 1, (cchTSV * itsvchMax)); /* turn all grays on */
return;
}
#endif /* NOT SAND */
bltbc(prgtsv, 0, (cchTSV * itsvchMax)); /* initializw rgtsv */
CachePara(docCur, selCur.cpFirst);
if (selCur.cpFirst == selCur.cpLim)
{
GetChpVals (&vchpSel,prgtsv); /* load up chp values */
GetHffn (&vchpSel,prgtsv); /* load up handle for font name */
}
else
{
typeCP CpLimNoSpaces(typeCP, typeCP);
cpLim = CpLimNoSpaces(selCur.cpFirst, selCur.cpLim);
FetchCp(docCur, selCur.cpFirst, 0, fcmProps);
blt(&vchpFetch, &chp, cwCHP); /* CHP for use in comparisons */
GetChpVals (&vchpFetch,prgtsv); /* load up chp values */
while ((vcpFetch + vccpFetch) < cpLim && ++ccpFetch <= ccpFetchMax)
{
/* Indicate which attributes should be grayed */
FetchCp(docNil, cpNil, 0, fcmProps);
chp.fSpecial = vchpFetch.fSpecial;
if (CchDiffer (&chp, &vchpFetch, cchCHP) != 0)
{
SetChUndef(prgtsv, &vchpFetch, &cchGray);
if (cchGray == itsvchMax) /* all gray - don't bother */
break;
}
}
if (ccpFetch > ccpFetchMax)
{
/* never finished - make everything gray */
bltbc(prgtsv, 1, (cchTSV * itsvchMax));
}
else
GetHffn (&chp,prgtsv); /* load up handle for font name */
}
}
GetRgtsvPapSel (prgtsv)
TSV *prgtsv;
{
/* Return properties for the paragraph menu. */
/* Using selCur, the current para props are left in vpapAbs and the paragraph
attributes in rgtsv are set to gray if that attribute differs from that
in the previous paragraph. Up to cparaMax paragraphs will be checked */
int cparaGray = 0; /* number of undefined (grayed) paragraph attributes */
/* max number of calls to CachePara */
#define cparaMax 50
int cpara = 0;
struct PAP pap;
CachePara(docCur, selCur.cpFirst);
#ifdef ENABLE /* we will show defaults even if the cursor is next to endmark */
if (selCur.cpFirst == cpMacCur)
{
bltbc(prgtsv, 1, (cchTSV * itsvparaMax)); /* turn all grays on */
return;
}
#endif
bltbc(prgtsv, 0, (cchTSV * itsvparaMax)); /* initializw rgtsv */
blt(&vpapAbs, &pap, cwPAP); /* save 1st paragraph for compares */
GetPapVals (&pap,prgtsv); /* load rgtsv with pap values */
while (vcpLimParaCache < selCur.cpLim && ++cpara <= cparaMax)
{
/* If any props are different, set appropriate flags */
CachePara(docCur, vcpLimParaCache);
if (CchDiffer(&pap, &vpapAbs, (cwPAPBase * cchINT)) != 0)
{
SetParaUndef(prgtsv, &vpapAbs, &cparaGray);
if (cparaGray == itsvparaMax) /* all gray - don't bother */
break;
}
}
if (cpara > cparaMax)
/* never finished - make everything gray */
bltbc(prgtsv, 1, (cchTSV * itsvparaMax));
}
NEAR GetChpVals (pchp,prgtsv) /* load chp values into rgtsv */
register struct CHP *pchp;
register TSV *prgtsv;
{
(prgtsv+itsvBold)->wTsv = pchp->fBold;
(prgtsv+itsvItalic)->wTsv = pchp->fItalic;
(prgtsv+itsvUline)->wTsv = pchp->fUline;
(prgtsv+itsvFfn)->wTsv = pchp->ftc;
(prgtsv+itsvSize)->wTsv = pchp->hps;
/* sub/superscripts - note that value is stored
as a signed integer, so we can just check for
the value relative to 0 */
(int)((prgtsv+itsvPosition)->wTsv) = (char)pchp->hpsPos;
}
NEAR GetPapVals (ppap,prgtsv) /* load pap values into rgtsv */
register struct PAP *ppap;
register TSV *prgtsv;
{
(prgtsv+itsvJust)->wTsv = ppap->jc;
(prgtsv+itsvSpacing)->wTsv = ppap->dyaLine;
(prgtsv+itsvLIndent)->wTsv = ppap->dxaLeft;
(prgtsv+itsvFIndent)->wTsv = ppap->dxaLeft1;
(prgtsv+itsvRIndent)->wTsv = ppap->dxaRight;
}
NEAR GetHffn (pchp,prgtsv) /* load font name handle into rgtsv */
register struct CHP *pchp;
register TSV *prgtsv;
{
union FCID fcid;
extern struct FFN **MpFcidHffn();
/* store handle for font name in font name entry */
Assert(sizeof(struct FFN **) == sizeof(prgtsv->wTsv));
fcid.strFcid.doc = docCur;
fcid.strFcid.ftc = pchp->ftc + (pchp->ftcXtra << 6);
(struct FFN **)((prgtsv+itsvFfn)->wTsv) = MpFcidHffn(&fcid);
}
NEAR SetChUndef(prgtsv, pchp, pcchGray)
register TSV *prgtsv;
register struct CHP *pchp;
int *pcchGray;
{
/* compare chp to values stored in rgtsv and set undefined
flags for differing fields of interest. */
/* BOLD */
if ((prgtsv+itsvBold)->fGray == 0)
if (pchp->fBold != (prgtsv+itsvBold)->wTsv)
{
(prgtsv+itsvBold)->fGray = 1;
(*pcchGray)++;
}
/* ITALIC */
if ((prgtsv+itsvItalic)->fGray == 0)
if (pchp->fItalic != (prgtsv+itsvItalic)->wTsv)
{
(prgtsv+itsvItalic)->fGray = 1;
(*pcchGray)++;
}
/* UNDERLINE */
if ((prgtsv+itsvUline)->fGray == 0)
if (pchp->fUline != (prgtsv+itsvUline)->wTsv)
{
(prgtsv+itsvUline)->fGray = 1;
(*pcchGray)++;
}
/* Position (SUBSCRIPT OR SUPERSCRIPT) */
/* if different: gray both sub and superscript.
The properties are really mutually exclusive,
even though they appear on the menu as separate
items. Also, for Write, off and gray are the
same, so if either is grayed, the other must be
either off or gray, so the appearance is the
same. */
if ((prgtsv+itsvPosition)->fGray == 0)
if (pchp->hpsPos != (prgtsv+itsvPosition)->wTsv)
{
(prgtsv+itsvPosition)->fGray = 1;
(*pcchGray)++;
}
/* FONT NAME */
if ((prgtsv+itsvFfn)->fGray == 0)
if (pchp->ftc != (prgtsv+itsvFfn)->wTsv)
{
(prgtsv+itsvFfn)->fGray = 1;
(*pcchGray)++;
}
/* FONT SIZE */
if ((prgtsv+itsvSize)->fGray == 0)
if (pchp->hps != (prgtsv+itsvSize)->wTsv)
{
(prgtsv+itsvSize)->fGray = 1;
(*pcchGray)++;
}
}
NEAR SetParaUndef(prgtsv, ppap, pcparaGray)
register TSV *prgtsv;
register struct PAP *ppap;
int *pcparaGray;
{
/* compare pap to values stored in rgtsv and set undefined
flags for differing fields of interest. */
/* JUSTIFICATION */
if ((prgtsv+itsvJust)->fGray == 0)
if (ppap->jc != (prgtsv+itsvJust)->wTsv)
{
(prgtsv+itsvJust)->fGray = 1;
(*pcparaGray)++;
}
/* LINE SPACING */
if ((prgtsv+itsvSpacing)->fGray == 0)
if (ppap->dyaLine != (prgtsv+itsvSpacing)->wTsv)
{
(prgtsv+itsvSpacing)->fGray = 1;
(*pcparaGray)++;
}
/* LEFT INDENT */
if ((prgtsv+itsvLIndent)->fGray == 0)
if (ppap->dxaLeft != (prgtsv+itsvLIndent)->wTsv)
{
(prgtsv+itsvLIndent)->fGray = 1;
(*pcparaGray)++;
}
/* FIRST LINE INDENT */
if ((prgtsv+itsvFIndent)->fGray == 0)
if (ppap->dxaLeft1 != (prgtsv+itsvFIndent)->wTsv)
{
(prgtsv+itsvFIndent)->fGray = 1;
(*pcparaGray)++;
}
/* RIGHT INDENT */
if ((prgtsv+itsvRIndent)->fGray == 0)
if (ppap->dxaRight != (prgtsv+itsvRIndent)->wTsv)
{
(prgtsv+itsvRIndent)->fGray = 1;
(*pcparaGray)++;
}
}
/* C P L I M N O S P A C E S */
typeCP CpLimNoSpaces(cpFirst, cpLim)
typeCP cpFirst, cpLim;
{
/* Truncate trailing spaces unless only spaces are in sel. */
int cch;
typeCP cpLimOrig;
CHAR rgch[cchMaxSz];
cpLimOrig = cpLim;
FetchRgch(&cch, rgch, docCur, CpMax(cpFirst + cchMaxSz, cpLim) - cchMaxSz,
cpLim, cchMaxSz);
while (cch-- > 0 && rgch[cch] == chSpace)
{
--cpLim;
}
return cch < 0 ? cpLimOrig : cpLim;
} /* end of CpLimNoSpaces */
NEAR FNoSearchStr(hDlg)
HWND hDlg;
{
CHAR szBuf[255];
HWND hWndFrom = GetActiveWindow();
if (hDlg == hWndFrom || hDlg == (HANDLE)GetWindowWord(hWndFrom, GWW_HWNDPARENT))
{
if (GetDlgItemText(hDlg, idiFind, (LPSTR)szBuf, 255) == 0)
return(TRUE);
}
return(FALSE);
}
PhonyMenuAccelerator( menu, imi, lpfn )
int menu;
int imi;
FARPROC lpfn;
{
HMENU hSubmenu = GetSubMenu(vhMenu,menu);
SetAppMenu( hSubmenu , menu );
if (FIsMenuItemEnabled( hSubmenu , imi ))
{
HiliteMenuItem( hParentWw, vhMenu, menu, MF_BYPOSITION | MF_HILITE );
(*lpfn) ();
HiliteMenuItem( hParentWw, vhMenu, menu, MF_BYPOSITION );
}
}
FIsMenuItemEnabled (HMENU hMenu , int id )
{ /* Find out if a menu item in vhMenu is enabled. */
return !(GetMenuState(hMenu, id, MF_BYCOMMAND ) & (MF_DISABLED|MF_GRAYED));
}
int FAR PASCAL NewFont(HWND hwnd);
void MmwCommand(hWnd, wParam, hWndCtl, codeCtl)
HWND hWnd;
WORD wParam;
HWND hWndCtl;
WORD codeCtl;
{
#ifdef INEFFLOCKDOWN
extern FARPROC lpDialogHelp;
extern FARPROC lpDialogGoTo;
extern FARPROC lpDialogCharFormats;
extern FARPROC lpDialogParaFormats;
extern FARPROC lpDialogTabs;
extern FARPROC lpDialogDivision;
extern FARPROC lpDialogPrinterSetup;
#else
extern BOOL far PASCAL DialogPrinterSetup(HWND, unsigned, WORD, LONG);
extern BOOL far PASCAL DialogHelp(HWND, unsigned, WORD, LONG);
extern BOOL far PASCAL DialogGoTo(HWND, unsigned, WORD, LONG);
extern BOOL far PASCAL DialogCharFormats(HWND, unsigned, WORD, LONG);
extern BOOL far PASCAL DialogParaFormats(HWND, unsigned, WORD, LONG);
extern BOOL far PASCAL DialogTabs(HWND, unsigned, WORD, LONG);
extern BOOL far PASCAL DialogDivision(HWND, unsigned, WORD, LONG);
#endif
extern int vfPictSel;
extern CHAR *vpDlgBuf;
int DialogOk = 0;
int fQuit = fFalse;
if (wParam & fMenuItem)
{
switch (wParam & MENUMASK)
{
case FILEMENU:
switch(wParam)
{
case imiNew:
fnNewFile();
break;
case imiOpen:
fnOpenFile((LPSTR)NULL);
break;
case imiSave:
#if defined(OLE)
if (CloseUnfinishedObjects(TRUE) == FALSE)
return;
#endif
fnSave();
break;
case imiSaveAs:
#if defined(OLE)
if (CloseUnfinishedObjects(TRUE) == FALSE)
return;
#endif
fnSaveAs();
break;
case imiPrint:
fnPrPrinter();
break;
case imiPrintSetup:
/* Bring up the Change Printer dialog box. */
PrinterSetupDlg(FALSE);
break;
case imiRepaginate:
fnRepaginate();
break;
case imiQuit:
fnQuit(hWnd);
fQuit = fTrue;
break;
default:
break;
}
break;
case EDITMENU:
switch(wParam)
{
case imiUndo:
CmdUndo();
break;
case imiCut:
fnCutEdit();
break;
case imiCopy:
fnCopyEdit();
break;
case imiPaste:
#if defined(OLE)
vbObjLinkOnly = FALSE;
#endif
fnPasteEdit();
break;
#if defined(OLE)
case imiPasteSpecial:
vbObjLinkOnly = FALSE;
fnObjPasteSpecial();
break;
case imiPasteLink:
vbObjLinkOnly = TRUE;
fnPasteEdit();
break;
case imiInsertNew:
fnObjInsertNew();
break;
#endif
case imiMovePicture:
fnMovePicture();
break;
case imiSizePicture:
fnSizePicture();
break;
#if defined(OLE)
case imiProperties:
fnObjProperties();
break;
#endif
default:
break;
}
break;
#if defined(OLE)
case VERBMENU:
fnObjDoVerbs(wParam);
break;
#endif
case FINDMENU:
if (wParam != imiGoTo && wParam != imiFindAgain)
StartLongOp();
switch(wParam)
{
case imiFind:
fnFindText();
break;
case imiFindAgain:
fnFindAgain();
break;
case imiChange:
fnReplaceText();
break;
case imiGoTo:
{
#ifndef INEFFLOCKDOWN
FARPROC lpDialogGoTo = MakeProcInstance(DialogGoTo, hMmwModInstance);
if (!lpDialogGoTo)
goto LNotEnufMem;
#endif
DialogOk = OurDialogBox(hMmwModInstance, MAKEINTRESOURCE(dlgGoTo),
hParentWw, lpDialogGoTo);
#ifndef INEFFLOCKDOWN
FreeProcInstance(lpDialogGoTo);
#endif
/* the following block has been commentted out because
the corresponding file(DISP.C) doesn't inlcude MmwCatSt
routine anymore */
#if 0
{
extern void far MmwCatSt( HWND, BOOL );
MmwCatSt(hParentWw, FALSE);
}
#endif
break;
}
default:
break;
}
break;
case CHARMENU:
if (wParam != imiCharFormats)
StartLongOp();
{
/* rgtsv gets attributes and gray flags from CHP */
TSV rgtsv[itsvchMax];
CHAR rgbDlgBuf[sizeof(BOOL)];
void NEAR fnCharSelectFont(int);
/* GetRgtsvChpSel() fills up rgtsv */
GetRgtsvChpSel(rgtsv);
switch(wParam)
{
case imiCharNormal:
ApplyCLooks(0, sprmCPlain, 0);
break;
case imiBold:
ApplyCLooks(0, sprmCBold, (rgtsv[itsvBold].fGray != 0) ? TRUE :
!rgtsv[itsvBold].wTsv);
break;
case imiItalic:
ApplyCLooks(0, sprmCItalic, (rgtsv[itsvItalic].fGray != 0) ?
TRUE : !rgtsv[itsvItalic].wTsv);
break;
case imiUnderline:
ApplyCLooks(0, sprmCUline, (rgtsv[itsvUline].fGray != 0) ? TRUE
: !rgtsv[itsvUline].wTsv);
break;
case imiSuper:
/* Note that the value stored in rgtsv[itsvPosition].wTsv is
really a signed integer, so we can just check for 0, > 0, and <
0. */
ApplyCLooks(0, sprmCPos, !(rgtsv[itsvPosition].fGray == 0 &&
(int)rgtsv[itsvPosition].wTsv > 0) ? ypSubSuper : 0);
break;
case imiSub:
ApplyCLooks(0, sprmCPos, !(rgtsv[itsvPosition].fGray == 0 &&
(int)rgtsv[itsvPosition].wTsv < 0) ? -ypSubSuper : 0);
break;
#if 0
case imiFont1:
fnCharSelectFont(0);
break;
case imiFont2:
fnCharSelectFont(1);
break;
case imiFont3:
fnCharSelectFont(2);
break;
#endif
case imiSmFont:
if (CanChangeFont(-1))
{
ApplyCLooks(0, sprmCChgHps, -1);
vfSeeSel = TRUE;
}
break;
case imiLgFont:
if (CanChangeFont(1))
{
ApplyCLooks(0, sprmCChgHps, 1);
vfSeeSel = TRUE;
}
break;
case imiCharFormats:
{
#if 0
#ifndef INEFFLOCKDOWN
FARPROC lpDialogCharFormats = MakeProcInstance(DialogCharFormats, hMmwModInstance);
if (!lpDialogCharFormats)
goto LNotEnufMem;
#endif
vpDlgBuf = &rgbDlgBuf[0];
DialogOk = OurDialogBox(hMmwModInstance,
MAKEINTRESOURCE(dlgCharFormats),
hParentWw, lpDialogCharFormats);
#ifndef INEFFLOCKDOWN
FreeProcInstance(lpDialogCharFormats);
#endif
#else
DialogOk = NewFont(hParentWw);
#endif
break;
}
#if defined(JAPAN) & defined(IME_HIDDEN) //IME3.1J
//IME3.1J
case imiImeHidden:
ChangeImeConversionMode();
break;
#endif
default:
break;
}
#if defined(JAPAN) & defined(DBCS_IME) //Win3.1J
SetImeFont(vhWnd);
#endif
break;
}
case PARAMENU:
switch(wParam)
{
case imiParaNormal:
ApplyLooksParaS(0, sprmPNormal, 0);
if (vfPictSel)
{
CmdUnscalePic();
}
break;
case imiLeft:
ApplyLooksParaS(0, sprmPJc, jcLeft);
break;
case imiCenter:
ApplyLooksParaS(0, sprmPJc, jcCenter);
break;
case imiRight:
ApplyLooksParaS(0, sprmPJc, jcRight);
break;
case imiJustified:
ApplyLooksParaS(0, sprmPJc, jcBoth);
break;
case imiSingleSpace:
ApplyLooksPara(0, sprmPDyaLine, czaLine);
break;
case imiOneandhalfSpace:
ApplyLooksPara(0, sprmPDyaLine, czaLine * 3 / 2);
break;
case imiDoubleSpace:
ApplyLooksPara(0, sprmPDyaLine, czaLine * 2);
break;
case imiParaFormats:
{
#ifndef INEFFLOCKDOWN
FARPROC lpDialogParaFormats = MakeProcInstance(DialogParaFormats, hMmwModInstance);
if (!lpDialogParaFormats)
goto LNotEnufMem;
#endif
DialogOk = OurDialogBox(hMmwModInstance,
MAKEINTRESOURCE(dlgParaFormats),
hParentWw, lpDialogParaFormats);
#ifndef INEFFLOCKDOWN
FreeProcInstance(lpDialogParaFormats);
#endif
break;
}
default:
break;
}
break;
case DOCUMENU:
switch(wParam)
{
case imiFooter:
case imiHeader:
fnEditRunning(wParam);
break;
case imiShowRuler:
fnShowRuler();
break;
case imiTabs:
{
#ifndef INEFFLOCKDOWN
FARPROC lpDialogTabs = MakeProcInstance(DialogTabs, hMmwModInstance);
if (!lpDialogTabs)
goto LNotEnufMem;
#endif
DialogOk = OurDialogBox(hMmwModInstance, MAKEINTRESOURCE(dlgTabs),
hParentWw, lpDialogTabs);
#ifndef INEFFLOCKDOWN
FreeProcInstance(lpDialogTabs);
#endif
break;
}
case imiDivFormats:
{
#ifndef INEFFLOCKDOWN
FARPROC lpDialogDivision = MakeProcInstance(DialogDivision, hMmwModInstance);
if (!lpDialogDivision)
goto LNotEnufMem;
#endif
DialogOk = OurDialogBox(hMmwModInstance,
MAKEINTRESOURCE(dlgDivision),
hParentWw, lpDialogDivision);
#ifndef INEFFLOCKDOWN
FreeProcInstance(lpDialogDivision);
#endif
break;
}
default:
break;
}
break;
case HELPMENU:
{
int wHelpCode;
extern WORD wWinVer;
CHAR sz[ cchMaxFile ];
LDefaultHelp:
PchFillPchId( sz, IDSTRHELPF, sizeof(sz) );
switch(wParam)
{
case imiIndex:
WinHelp(hParentWw, (LPSTR)sz, HELP_INDEX, NULL);
break;
case imiHelpSearch:
WinHelp(hParentWw, (LPSTR)sz, HELP_PARTIALKEY, (DWORD)(LPSTR)"");
break;
case imiUsingHelp:
WinHelp(hParentWw, (LPSTR)NULL, HELP_HELPONHELP, NULL);
break;
default:
case imiAbout:
if (((wWinVer & 0xFF) >= 3) && ((wWinVer & 0xFF00) >= 0x0A00))
{
extern CHAR szMw_icon[];
extern CHAR szAppName[];
ShellAbout(hParentWw, szAppName, "",
LoadIcon( hMmwModInstance, (LPSTR)szMw_icon ));
}
break;
}
break;
}
default:
if (wParam == imiHelp)
{
#ifdef WIN30
wParam = imiIndex; /* For all Win3 applets, pressing F1
should bring up the Help Index */
#endif
goto LDefaultHelp;
}
}
if (DialogOk == -1)
{
LNotEnufMem:
#ifdef WIN30
WinFailure();
#else
Error(IDPMTNoMemory);
#endif
}
}
if (!fQuit)
UpdateInvalid(); /* To be sure we update the area behind dialogs */
}
#if 0
void NEAR fnCharSelectFont(iffn)
/* select the specified font from the three listed on char dropdown */
int iffn;
{
struct FFN *pffn;
int ftc;
extern CHAR rgffnFontMenu[3][ibFfnMax];
extern int docCur;
pffn = (struct FFN *)rgffnFontMenu[iffn];
ftc = FtcChkDocFfn(docCur, pffn);
if (ftc != ftcNil)
ApplyCLooks(0, sprmCFtc, ftc);
vfSeeSel = TRUE;
}
#endif
#ifdef JAPAN //Win3.1J
int KanjiFtc = ftcNil;
GetKanjiFtc(pchp)
struct CHP *pchp;
{
int ftc;
int CharSet;
CharSet = GetCharSetFromChp(pchp);
if (NATIVE_CHARSET == CharSet) {
KanjiFtc = GetFtcFromPchp(pchp);
return(ftcNil);
} else {
if(KanjiFtc == ftcNil)
ftc = SearchKanjiFtc(docCur); //Get set New szFfn chs
else
ftc = KanjiFtc;
return(ftc);
}
}
GetCharSetFromChp(pchp)
struct CHP *pchp;
{
TSV rgtsv[itsvchMax]; /* gets attributes and gray flags from CHP, PAP */
struct FFN **hffn;
GetHffn (pchp,rgtsv); /* load up handle for font name */
hffn = (struct FFN **)rgtsv[itsvFfn].wTsv;
return((*hffn)->chs);
}
extern CHAR saveKanjiDefFfn[ibFfnMax];
SearchKanjiFtc(doc)
/* looks for described font in docs ffntb - returns ftcNil if not found */
int doc;
{
int ftc;
int iffn, iffnMac;
struct FFNTB **hffntb;
struct FFN ***mpftchffn;
struct FFN *pffn;
ftc = ftcNil;
hffntb = HffntbGet(doc);
if (hffntb != 0) {
mpftchffn = (*hffntb)->mpftchffn;
iffnMac = (*hffntb)->iffnMac;
for (iffn = 0; iffn < iffnMac; iffn++) {
if ( (*mpftchffn[iffn])->chs == NATIVE_CHARSET &&
(*mpftchffn[iffn])->szFfn[0] != chGhost)
return(iffn);
}
}
pffn = (struct FFN *)saveKanjiDefFfn;
ftc = FtcChkDocFfn(doc, pffn);
if (ftc != ftcNil)
return(ftc);
return(ftcNil);
}
#endif

Reference in a new issue Copy permalink