1421 lines
40 KiB
C
1421 lines
40 KiB
C
/************************************************************/
|
||
/* 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
|
||
|