/************************************************************/
/* Windows Write, Copyright 1985-1992 Microsoft Corporation */
/************************************************************/
/* search.c Search/Replace */
/* Brodie Nov 25 83 */
/* Lipkie Nov 15 83 */
#define NOATOM
#define NOBITMAP
#define NOBRUSH
#define NOCLIPBOARD
#define NOCOLOR
#define NOCOMM
#define NOCREATESTRUCT
#define NODRAWTEXT
#define NOFONT
#ifndef JAPAN
#define NOGDI
#endif
#define NOGDICAPMASKS
#define NOHDC
#define NOICON
#define NOKEYSTATE
#define NOMEMMGR
#define NOMENUS
#define NOMETAFILE
#define NOOPENFILE
#define NOPEN
#define NORASTEROPS
#define NORECT
#define NOREGION
#define NOSCROLL
#define NOSHOWWINDOW
#define NOSOUND
#define NOSYSCOMMANDS
#define NOSYSMETRICS
#define NOTEXTMETRIC
#define NOWH
#define NOWINSTYLES
#define NOWNDCLASS
#include <windows.h>
#define NOIDISAVEPRINT
#include "mw.h"
#include "dlgdefs.h"
#include "cmddefs.h"
#include "docdefs.h"
#include "str.h"
#define NOKCCODES
#include "ch.h"
#include "editdefs.h"
#include "propdefs.h"
#include "filedefs.h"
#include "dispdefs.h"
#include "wwdefs.h"
#include "fkpdefs.h"
#include "fmtdefs.h"
#if defined(JAPAN) || defined(KOREA) //T-HIROYN Win3.1
#include "kanji.h"
extern int vcchFetch;
#endif
#ifdef INEFFLOCKDOWN
extern FARPROC lpDialogFind;
extern FARPROC lpDialogChange;
#else
FARPROC lpDialogFind = NULL;
FARPROC lpDialogChange = NULL;
BOOL far PASCAL DialogFind(HWND, unsigned, WORD, LONG);
BOOL far PASCAL DialogChange(HWND, unsigned, WORD, LONG);
#endif
extern HANDLE hMmwModInstance;
extern HWND vhDlgFind;
extern HWND vhDlgChange;
extern HANDLE hParentWw; /* Handle to the parent window */
extern int vfCursorVisible;
extern int vfOutOfMemory;
extern struct WWD rgwwd[];
extern int wwMac;
#ifdef ENABLE /* no pDialogCur and ActiveWindow */
extern WINDOWPTR windowSearch;
extern WINDOWPTR windowRep;
extern WINDOWPTR pDialogCur;
extern WINDOWPTR ActiveWindow;
extern int cxEditScroll;/* not sure how cxEditScroll is used */
extern struct SEL selSearch;
#endif
extern struct FKPD vfkpdParaIns;
extern struct PAP *vppapNormal;
extern typeFC fcMacPapIns;
extern int wwCur;
extern struct WWD *pwwdCur;
extern struct CHP vchpInsert;
extern struct PAP vpapPrevIns;
extern int vfSelecting;
extern typeCP cpMacCur;
extern typeCP cpMinCur;
extern int vfSeeSel;
extern int vfSeeEdgeSel;
extern int docCur;
extern struct SEL selCur;
extern typeCP vcpFetch;
extern int vccpFetch;
extern CHAR *vpchFetch;
extern struct UAB vuab;
extern int vfSysFull;
extern struct PAP vpapAbs;
extern struct CHP vchpFetch;
extern int ferror;
extern typeCP cpWall;
/* Globals used to store settings of flags. Used to propose responses. */
extern BOOL fParaReplace /* = false initially */;
extern BOOL fReplConfirm /* = TRUE initially */;
#if defined(JAPAN) || defined(KOREA) /*t-Yoshio*/
extern BOOL fSearchDist /* = true initially */;
#endif
extern BOOL fSearchWord /* = false initially */;
extern BOOL fSearchCase /* = false initially */;
extern BOOL fSpecialMatch;
extern BOOL fMatchedWhite /* = false initially */;
extern CHAR (**hszSearch)[]; /* Default search string */
extern CHAR (**hszReplace)[]; /* Default replace string */
extern CHAR (**hszFlatSearch)[]; /* All lower case version of search string */
extern CHAR (**hszRealReplace)[]; /* used for building replacement text */
extern CHAR (**hszCaseReplace)[]; /* used for building replacement text with
appropriate capitalization. */
extern typeCP cpMatchLim;
extern int vfDidSearch;
extern CHAR *szSearch;
extern CHAR (**HszCreate())[];
extern HWND vhWndMsgBoxParent;
extern HCURSOR vhcIBeam;
extern HCURSOR vhcArrow;
#ifdef INTL
extern CHAR szAppName[];
extern CHAR szSepName[];
#endif
#if defined(JAPAN) || defined(KOREA) /*t-Yoshio*/
char DistSearchString[513];
#endif
NEAR DoSearch(void);
NEAR DoReplace(int, int);
typeCP NEAR CpSearchSz(typeCP, typeCP, CHAR *);
NEAR FMakeFlat(int);
NEAR SetSpecialMatch(void);
NEAR FSetParaReplace(int);
NEAR WCaseCp(typeCP, typeCP);
NEAR SetChangeString(HANDLE, int);
NEAR PutCpInWwVertSrch(typeCP);
#ifndef NOLA
BOOL (NEAR FAbort(void));
#endif
BOOL (NEAR FWordCp(typeCP, typeCP));
BOOL (NEAR FChMatch(int, int *, BOOL));
#if defined(JAPAN) || defined(KOREA) /*t-Yoshio*/
BOOL (NEAR J_FChMatch(CHAR, CHAR, int *,int *));
#endif
NEAR InsertPapsForReplace(typeFC);
NEAR DestroyModeless(HWND *);
NEAR FDlgSzTooLong(HWND, int, CHAR *, int);
NEAR idiMsgResponse(HWND, int, int);
BOOL CheckEnableButton(HANDLE, HANDLE);
BOOL bInSearchReplace = FALSE; // avoid close when we are searching!
#define CmdReplace(fThenFind) bInSearchReplace = TRUE; \
DoReplace(false, fThenFind); \
bInSearchReplace = FALSE
#define CmdReplaceAll() bInSearchReplace = TRUE; \
DoReplace(true, false); \
bInSearchReplace = FALSE
#ifndef NOLA
static int fAbortSearch = FALSE;
#endif
static int fChangeSel;
static int fSelSave = FALSE;
static struct SEL selSave;
#ifdef DBCS
/* Additional variables to handle white-space matching
for the DBCS space. */
static int cbLastMatch;
/* Since CpFirstSty(, styChar) calls on FetchCp(), any assumption
made about the validity of global variables set by FetchCp()
is no longer valid. We explicitly save those variables after
each FetchCp and use those instead. (Used in CpSearchSz().)*/
static typeCP cpFetchSave;
static int ccpFetchSave;
static CHAR *pchFetchSave;
/* Also, we move some of the local variables out from
CpSearchSz() so that they can be changed by FChMatch(). */
/*
int ichDoc;
int cchMatched;
typeCP cpFetchNext;
*/
#endif
NEAR DoSearch()
{
int cch;
typeCP cpSearch;
typeCP cpSearchLim;
typeCP cpSearchNext;
typeCP cpWallActual;
typeCP cpMatchFirst;
typeCP CpMin();
int idpmt;
int fDidSearch;
if (docCur == docNil)
return;
cch = CchSz(**hszSearch)-1;
if(cch == 0)
{
/* this should only occur if the user execute Repeat last find without having
previously defined a search string. */
Error(IDPMTNotFound);
return;
}
SetSpecialMatch();
if(!FMakeFlat(cch))
return;
#if defined(JAPAN) || defined(KOREA) /*t-Yoshio*/
if(!fSpecialMatch && !fSearchDist)
{
myHantoZen(**hszFlatSearch,DistSearchString,513);
cch = CchSz(DistSearchString)-1;
}
#endif
fDidSearch = vfDidSearch;
cpWallActual = fDidSearch ? CpMin(cpWall, cpMacCur) : cpMacCur;
cpSearchNext = fDidSearch ? selCur.cpLim : selCur.cpFirst;
cpSearchLim = (cpSearchNext <= cpWallActual) ? cpWallActual : cpMacCur;
{
do
{
ContinueSearch:
#if defined(JAPAN) || defined(KOREA) /*t-Yoshio*/
if(!fSpecialMatch && !fSearchDist)
cpSearch = CpSearchSz(cpSearchNext,cpSearchLim,DistSearchString);
else
cpSearch = CpSearchSz(cpSearchNext,cpSearchLim,**hszFlatSearch);
#else
cpSearch=CpSearchSz(cpSearchNext,cpSearchLim,**hszFlatSearch);
#endif
if (cpSearch == cpNil)
{
#ifndef NOLA
if (fAbortSearch)
{
Error(IDPMTCancelSearch);
fAbortSearch = FALSE;
vfDidSearch = FALSE;
FreeH(hszFlatSearch);
return;
}
#endif
if (cpSearchLim == cpWall && fDidSearch)
{
SearchFail: Error(vfDidSearch ? IDPMTSearchDone :
IDPMTNotFound);
if (vfDidSearch) /* did we previously have a match?*/
{ /* Yes, do setup for next pass */
/* clear flag so we can search some more */
vfDidSearch = false;
/* set "Wall" to immediately after last match */
cpWall = selCur.cpLim;
/* ask that selection be displayed */
vfSeeSel = vfSeeEdgeSel = TRUE;
}
FreeH(hszFlatSearch);
return;
}
else
{
cpSearchNext = cpMinCur;
cpSearchLim = cpWall;
fDidSearch = true;
goto ContinueSearch;
}
}
#ifdef DBCS /* was in JAPAN */
cpSearchNext = CpLastStyChar( cpSearch ) + 1;
#else
cpSearchNext = CpLastStyChar( cpSearch + 1 );
#endif
}
/*--- while (fSearchWord && !FWordCp(cpSearch, cpMatchLim-cpSearch));--*/
while (!FCpValid(cpSearch, cpMatchLim - cpSearch));
}
if (!vfDidSearch)
{
cpWall = cpSearch;
vfDidSearch = true;
}
/*Select( CpFirstSty( cpSearch, styChar ), CpLastStyChar( cpMatchLim ) );*/
if ( (cpMatchFirst = CpFirstSty( cpSearch, styChar )) != cpMatchLim )
Select( cpMatchFirst, cpMatchLim );
PutCpInWwVertSrch(selCur.cpFirst);
vfSeeSel = vfSeeEdgeSel = TRUE;
FreeH(hszFlatSearch);
}
NEAR DoReplace(fReplaceAll, fThenFind)
int fReplaceAll;
int fThenFind;
{
/* Replace now works as follows:
if the current selection is the search text, then replace it with
the replace text and jump to the next occurrence of the search text.
Otherwise, just jump to the next occurrence of the search text.
If fReplaceAll is true, then repeat this operation until the end
of the document. */
int cch;
typeCP cpSearchStart;
typeCP cpSearch;
typeCP cpSearchNext;
typeCP cpSearchLim;
typeCP cpSearchNow;
typeCP cpSearchLimNow;
typeCP dcp;
BOOL f1CharSel;
BOOL fFirstTime;
int ich;
int cchReplace;
int cwReplace;
int iCurCase;
int iLastCase;
typeFC fcCaseSz;
typeCP cpMacTextT;
typeCP cpWallActual;
int fDidSearch = vfDidSearch;
struct CHP chp;
typeCP cpMacSave;
iLastCase = -1; /* indicate that the string pointed to by hszCaseReplace
has not been given a value yet. */
if (!FWriteOk(fwcNil) || docCur == docNil)
/* Out of memory, read only document, etc */
return;
cch = CchSz(**hszSearch)-1;
if(cch == 0)
{
Error(IDPMTNotFound);
return;
}
SetSpecialMatch();
if(!FMakeFlat(cch))
return;
#if defined(JAPAN) || defined(KOREA) /*t-Yoshio*/
if(!fSpecialMatch && !fSearchDist)
{
myHantoZen(**hszFlatSearch,DistSearchString,513);
cch = CchSz(DistSearchString)-1;
}
#endif
cwReplace = CwFromCch(cchReplace = CchSz(**hszReplace));
if(FNoHeap(hszRealReplace = (CHAR (**) [])HAllocate(cwReplace)))
{
FreeH(hszFlatSearch);
return;
}
bltbyte(**hszReplace, **hszRealReplace, cchReplace);
if(FNoHeap(hszCaseReplace = (CHAR (**) [])HAllocate(cwReplace)))
{
FreeH(hszFlatSearch);
FreeH(hszRealReplace);
return;
}
if(!FSetParaReplace(cchReplace))
{
FreeH(hszFlatSearch);
FreeH(hszCaseReplace);
FreeH(hszRealReplace);
return;
}
cch = CchSz(**hszRealReplace)-1;
fFirstTime = TRUE;
cpWallActual = fDidSearch ? CpMin(cpWall, cpMacCur) : cpMacCur;
cpSearchNow = cpSearchStart = selCur.cpFirst;
if (fReplaceAll || !fThenFind)
cpSearchLim = selCur.cpLim;
else
cpSearchLim = (cpSearchStart < cpWallActual) ? cpWallActual : cpMacCur;
cpSearchLimNow = selCur.cpLim;
if (fReplaceAll)
{
cpWallActual = cpSearchLim;
fDidSearch = true;
}
NoUndo(); /* Prevent the SetUndo from getting merged with adjacent stuff */
cpMacTextT = CpMacText(docCur);
if(cpSearchLimNow > cpMacTextT)
SetUndo(uacDelNS, docCur, cp0, cpMacTextT, docNil, cpNil, cp0, 0);
else
SetUndo(uacDelNS, docCur, cpSearchStart, cpSearchLimNow - cpSearchStart,
docNil, cpNil, cp0, 0);
if (ferror) goto MemoryError;
cpSearchNext = cpSearchStart;
{
do
{
/* ForcePmt(IDPMTSearching);*/
do
{
ContinueSearch:
#if defined(JAPAN) || defined(KOREA) /*t-Yoshio*/
if(!fSpecialMatch && !fSearchDist)
cpSearch = CpSearchSz(cpSearchNext,cpSearchLim,DistSearchString);
else
cpSearch = CpSearchSz(cpSearchNext,cpSearchLim,**hszFlatSearch);
#else
cpSearch = CpSearchSz(cpSearchNext,cpSearchLim,**hszFlatSearch);
#endif
if (cpSearch == cpNil)
if ((cpSearchLim == cpWallActual && fDidSearch) || fAbortSearch)
DoneReplacingN:
{
DoneReplacingP:
FreeH(hszFlatSearch);
FreeH(hszCaseReplace);
FreeH(hszRealReplace);
cpMacTextT = CpMacText(docCur);
if (fReplaceAll || fFirstTime)
{
if(cpSearchLimNow > cpMacTextT)
SetUndo(uacInsert,docCur,cp0,
cpMacTextT,docNil,cpNil,cp0,0);
else
SetUndo(uacInsert,docCur,cpSearchStart,
cpSearchLimNow - cpSearchStart,
docNil,cpNil,cp0,0);
if (ferror) goto MemoryError;
vuab.uac = uacReplGlobal;
SetUndoMenuStr(IDSTRUndoBase);
/*Select( CpFirstSty( cpSearchStart, styChar ),
CpLastStyChar( cpSearchLimNow ) );*/
Select( CpFirstSty( cpSearchStart, styChar ),
(fReplaceAll ? cpSearchStart : cpSearchLimNow) );
vfSeeSel = fReplaceAll;
if (fReplaceAll)
{ /* reestablish the search after a changeall in case of a F3 next time */
vfDidSearch = false;
cpWall = selCur.cpLim;
}
}
else if (!fReplaceAll)
{
if (cpSearch == cpNil)
/*Select( CpFirstSty( cpSearchStart, styChar ),
CpLastStyChar( cpSearchLimNow ) );*/
Select( CpFirstSty( cpSearchStart, styChar ),
cpSearchLimNow );
else if (!fFirstTime)
/*Select( CpFirstSty( cpSearch, styChar ),
CpLastStyChar( cpMatchLim ) );*/
Select( CpFirstSty( cpSearch, styChar ),
cpMatchLim );
PutCpInWwVertSrch(selCur.cpFirst);
vfSeeSel = vfSeeEdgeSel = TRUE;
}
if (fAbortSearch)
{
fAbortSearch = FALSE;
Error(IDPMTCancelSearch);
}
else if (fFirstTime)
Error(fReplaceAll ? IDPMTNoReplace : (vfDidSearch ? IDPMTSearchDone : IDPMTNotFound));
return;
}
else
{
cpSearchNext = cpMinCur;
cpSearchLim = cpWallActual;
fDidSearch = true;
goto ContinueSearch;
}
#ifdef DBCS /* was in JAPAN */
cpSearchNext = CpLastStyChar( cpSearch ) + 1;
#else
cpSearchNext = CpLastStyChar( cpSearch + 1 );
#endif
}
/* while(fSearchWord && !FWordCp(cpSearch,cpMatchLim - cpSearch));*/
while(!FCpValid(cpSearch, cpMatchLim - cpSearch));
if (!fReplaceAll && (cpSearch != cpSearchNow || cpMatchLim != cpSearchLimNow))
{
if (fThenFind)
{ /* Get here if: Did a Change, then Find. Could not
do the change, but did find a next occurence */
cpSearchNow = cpSearchNext = cpSearchStart = cpSearch;
cpSearchLimNow = cpMatchLim;
fFirstTime = false; /* suppress error message */
SetUndo(uacInsert, docCur, cpSearchStart,
cpSearchLimNow - cpSearchStart, docNil, cpNil, cp0, 0);
if (ferror) goto MemoryError;
if (!vfDidSearch)
{
cpWall = cpSearch;
vfDidSearch = true;
}
/*---- continue;----*/
goto DoneReplacingN;
}
fFirstTime = true; /* Cause error message */
cpSearchStart = cpSearchNow;
cpSearchLim = cpSearchLimNow;
goto DoneReplacingN;
}
/*----- vfDidSearch = true;----*/
#ifdef FOOTNOTES
if(FEditFtn(cpSearch, cpMatchLim))
{
ferror = false; /* Reset error condition so that we don't
deallocate strings twice (KJS) */
continue;
}
#endif
fFirstTime = FALSE;
if (vfOutOfMemory || vfSysFull)
{ /* Out of memory (heap or disk) */
Error(IDPMTNoMemory);
FreeH(hszFlatSearch);
FreeH(hszRealReplace);
FreeH(hszCaseReplace);
cpMacTextT = CpMacText(docCur);
if(cpSearchLim > cpMacTextT)
SetUndo(uacInsert,docCur,cp0,cpMacTextT,docNil,cpNil,cp0,0);
else
SetUndo(uacInsert,docCur,cpSearchStart,
cpSearchLimNow - cpSearchStart,docNil,cpNil,cp0,0);
if (ferror)
NoUndo();
else
vuab.uac = uacReplGlobal;
return;
}
FetchCp(docCur, cpSearch, 0, fcmProps); /* Get props of first char
that we are replacing */
blt(&vchpFetch, &chp, cwCHP);
chp.fSpecial = false;
iCurCase = 0; /* assume that the replacement string doesn't
require special capitalization */
/* if we're not matching upper/lower case call WCaseCp to determine
the capitalization pattern of the matched string */
if (!fSearchCase)
iCurCase = WCaseCp(cpSearch, cpMatchLim - cpSearch);
/* if the new capitalization pattern of the matched string
doesn't match the current contents of hszCaseReplace,
copy the replacement string to hszCaseReplace and transform
hszCaseReplace to conform to the new pattern */
if (iCurCase != iLastCase)
switch (iCurCase)
{
default:
case 0: /* no special capitalization required */
bltbyte(**hszRealReplace, **hszCaseReplace, cch+1);
break;
case 1: /* first character of string must be capitalized */
bltbyte(**hszRealReplace, **hszCaseReplace, cch+1);
***hszCaseReplace = ChUpper(***hszRealReplace);
break;
case 2: /* all characters must be capitalized */
#ifdef DBCS //t-Yoshio
for (ich = 0; ich < cch;) {
if(!IsDbcsLeadByte((BYTE)(**hszRealReplace)[ich])) {
(**hszCaseReplace)[ich] =
ChUpper((**hszRealReplace)[ich]);
ich++;
}
else {
(**hszCaseReplace)[ich] = (**hszRealReplace)[ich];
(**hszCaseReplace)[ich+1] = (**hszRealReplace)[ich+1]; ich+=2;
}
}
#else
for (ich = 0; ich < cch;ich++)
(**hszCaseReplace)[ich] = ChUpper((**hszRealReplace)[ich]);
#endif
break;
}
/* do CachePara to find the current para props. CachePara has the
side effect of setting vpapAbs */
CachePara(docCur, cpSearch);
/* if the capitalization pattern has changed OR
the character properties of the replacement text don't match
those of the last insert OR
the paragraph properties of the replacement text don't match
those of the last insert, THEN
1) call NewChpIns to write a run describing the character
properties of the previous insertion text,
2) call FcWScratch to write the characters of the replacement
string to the scratch file,
3) if we are replacing paragraph marks, call InsertPapsForReplace
to write runs describing each paragraph in the replacement
string */
if (iCurCase != iLastCase ||
CchDiffer(&vchpInsert,&chp,cchCHP) != 0 ||
(fParaReplace && CchDiffer(&vpapPrevIns, &vpapAbs, cchPAP) != 0))
{
NewChpIns(&chp);
fcCaseSz = FcWScratch(**hszCaseReplace,cch);
if (fParaReplace)
InsertPapsForReplace(fcCaseSz);
}
/* Now since we have written the proper replacement text to
the scratch file and have setup the character and paragraph runs to
describe that text, simply do a replace to insert the replacement
text into the piece table */
Replace(docCur, cpSearch, cp0, fnScratch, fcCaseSz, (typeFC) cch);
if (ferror) goto MemoryError;
#ifdef JAPAN //T-HIROYN Win3.1
/* When we replace from ANSI CharSet string to SHIFTJIS CharSet String
We needs follows */
{
struct CHP savechpT;
typeCP cpF, cpFirst, cpLim, kcpF, kcpL;
int cchF;
int kanjiftc;
CHAR *rp;
CHAR ch, bSet;
int cchS, cblen;
CHAR rgch[ cchCHP + 1 ];
rgch [0] = sprmCSame;
if(NATIVE_CHARSET != GetCharSetFromChp(&chp)) {
kanjiftc = GetKanjiFtc(&chp);
savechpT = chp;
cpFirst = cpSearch;
do {
FetchCp(docCur, cpFirst, 0, fcmChars);
cpF = vcpFetch;
cchF = vcchFetch;
rp = vpchFetch;
if ((cpF+cchF) < cpSearch + cch)
cpLim = (cpF+cchF);
else
cpLim = cpSearch + cch;
cpFirst = kcpL;
cchS = 0;
kcpF = cpF;
while ( kcpF < cpLim ) {
ch = *rp;
bSet = FALSE;
if( FKana(ch) || IsDBCSLeadByte(ch) ) {
cblen = GetKanjiStringLen(cchS, cchF, rp);
bSet = TRUE;
} else {
cblen = GetAlphaStringLen(cchS, cchF, rp);
}
kcpL = kcpF + cblen;
cchS += cblen;
rp += cblen;
if(bSet) {
SetFtcToPchp(&chp, kanjiftc);
bltbyte( &chp, &rgch [1], cchCHP );
AddSprmCps(rgch, docCur, kcpF, kcpL);
}
kcpF = kcpL;
}
cpFirst = kcpF;
} while ((cpF + cchF) < cpSearch + cch );
chp = savechpT;
}
} // END JAPAN
#endif
iLastCase = iCurCase; /* record new capitalization pattern */
/* Now delete the found text from the piece table*/
cpMacSave = cpMacCur;
Replace(docCur, cpSearch+cch, cpMatchLim - cpSearch, fnNil, fc0, fc0);
dcp = cpMacSave - cpMacCur; /* Calculate dcp here because picture
paragraphs may have interfered with deleting */
if (ferror) goto MemoryError;
if (!fReplaceAll)
{
SetUndo(uacInsert, docCur, cpSearch, (typeCP) cch,
docNil, cpNil, cp0, 0);
if (ferror) goto MemoryError;
SetUndoMenuStr(IDSTRUndoBase);
}
cpSearchLim += cch - dcp;
cpMatchLim += cch - dcp;
cpWallActual += cch - dcp;
#ifdef DBCS /* was in JAPAN */
cpSearchNext = cpMatchLim;
#else
cpSearchNext = CpLastStyChar( cpMatchLim );
#endif
if (fReplaceAll)
cpSearchLimNow = cpSearchLim;
}
while (fReplaceAll);
}
if (fThenFind)
{
do
{
ContinueSearch2:
#if defined(JAPAN) || defined(KOREA) /*t-Yoshio*/
if(!fSpecialMatch && !fSearchDist)
cpSearch = CpSearchSz(cpSearchNext,cpSearchLim,DistSearchString);
else
cpSearch = CpSearchSz(cpSearchNext,cpSearchLim,**hszFlatSearch);
if(cpSearch == cpNil)
#else
if ((cpSearch = CpSearchSz(cpSearchNext, cpSearchLim,
**hszFlatSearch)) == cpNil)
#endif
{
if ((cpSearchLim == cpWallActual && fDidSearch) ||
fAbortSearch)
{
fFirstTime = false; /* Supress error message */
/*Select( CpFirstSty( cpSearchStart, styChar ),
CpLastStyChar( cpMatchLim ) );*/
Select( CpFirstSty( cpSearchStart, styChar ),
cpMatchLim );
PutCpInWwVertSrch(selCur.cpFirst);
cpSearchLimNow = cpMatchLim;
Error(fAbortSearch ?
IDPMTCancelSearch : IDPMTSearchDone);
fAbortSearch = FALSE;
vfDidSearch = false;
cpWall = selCur.cpLim;
goto DoneReplacingP;
}
else
{
cpSearchNext = cpMinCur;
cpSearchLim = cpWallActual;
fDidSearch = true;
goto ContinueSearch2;
}
}
#ifdef DBCS /* was in JAPAN */
cpSearchNext = CpLastStyChar( cpSearch ) + 1;
#else
cpSearchNext = CpLastStyChar( cpSearch + 1 );
#endif
}
/*-- while(fSearchWord && !FWordCp(cpSearch,cpMatchLim - cpSearch));*/
while(!FCpValid(cpSearch, cpMatchLim - cpSearch));
if (!vfDidSearch)
{
cpWall = cpSearch;
vfDidSearch = true;
}
}
goto DoneReplacingP;
MemoryError:
FreeH(hszFlatSearch);
FreeH(hszCaseReplace);
FreeH(hszRealReplace);
NoUndo();
/* counter off the losing insertion point after incomplete change all */
if (fReplaceAll && fSelSave)
{
selCur.cpFirst = selSave.cpFirst;
selCur.cpLim = selSave.cpLim;
}
}
#ifdef DBCS
BOOL fDBCS = FALSE;
#endif
typeCP NEAR CpSearchSz(cpFirst, cpMacSearch, sz)
typeCP cpFirst;
typeCP cpMacSearch;
CHAR *sz;
{{ /* Finds first occurrence of sz in docCur starting at cpFirst */
/* Returns cpNil if not found */
/* Ignore case of letters if fSearchCase is FALSE. This assumes that the
pattern has already been folded to lower case. */
CHAR ch;
BOOL fMatched;
int ichPat = 0;
int ichDoc = 0;
int cchMatched = 0;
typeCP cpFetchNext;
/*EVENT event;*/
#ifdef DBCS
typeCP cpFound;
CHAR rgchT[dcpAvgSent];
#if defined(JAPAN) || defined(KOREA) /*t-Yoshio*/
CHAR chNext;
CHAR dch[3];
#endif
#endif
szSearch = sz;
#ifdef DBCS
/* Initialize those local variables moved out from this
function. */
ichDoc = 0;
cchMatched = 0;
pchFetchSave = &rgchT[0];
cbLastMatch = 1;
#endif
#ifdef DBCS
FetchCp(docCur, cpFirst, 0, fcmChars + fcmNoExpand);
cpFetchSave = vcpFetch;
#ifdef JAPAN //raid 4709 bug fix
bltbyte(vpchFetch, rgchT, ccpFetchSave =
((vccpFetch > (dcpAvgSent-2)) ? (dcpAvgSent-2) : vccpFetch));
{
int inc;
BOOL bDBCSBreak = FALSE;
typeCP saveVcpFetch;
for(inc = 0;inc < ccpFetchSave;inc++) {
if(IsDBCSLeadByte((BYTE)rgchT[inc])) {
inc++;
if(inc >= ccpFetchSave) {
bDBCSBreak = TRUE;
break;
}
}
}
if(bDBCSBreak) {
saveVcpFetch = vcpFetch;
FetchCp(docCur, cpFetchSave + ccpFetchSave,
0, fcmChars + fcmNoExpand);
bltbyte(vpchFetch, rgchT+ccpFetchSave,1);
ccpFetchSave++;
vcpFetch = saveVcpFetch;
}
}
#else //JAPAN
bltbyte(vpchFetch, rgchT,
ccpFetchSave = ((vccpFetch > dcpAvgSent) ? dcpAvgSent : vccpFetch));
if (vccpFetch > dcpAvgSent) {
int inc;
fDBCS = 0;
for(inc = 0;inc < dcpAvgSent;inc++) {
if(fDBCS)
fDBCS = 0;
else
fDBCS = IsDBCSLeadByte((BYTE)rgchT[inc]);
}
if(fDBCS)
ccpFetchSave--;
fDBCS = 0;
}
#endif //JAPAN
Assert(cpFetchSave == cpFirst);
cpFetchNext = cpFetchSave + ccpFetchSave;
#else //DBCS
FetchCp(docCur, cpFirst, 0, fcmChars + fcmNoExpand);
Assert(vcpFetch == cpFirst);
cpFetchNext = vcpFetch + vccpFetch;
#endif //DBCS
fMatchedWhite = false;
for (; ;)
{
#if defined(JAPAN) || defined(KOREA) /*t-Yoshio*/
cbLastMatch = 1;
#endif
if (szSearch[ichPat] == '\0' )
{{ /* Found it */
#ifdef DBCS
typeCP cpFound;
#if defined(JAPAN) || defined(KOREA) /*t-Yoshio*/
if(IsDBCSLeadByte((BYTE)ch))
cpMatchLim = vcpFetch+ichDoc - (fMatchedWhite ? 2 : 0);
else
cpMatchLim = vcpFetch+ichDoc - (fMatchedWhite ? 1 : 0);
#else
cpMatchLim = vcpFetch+ichDoc - (fMatchedWhite ? 1 : 0);
#endif
cpFound = cpFetchSave + ichDoc - cchMatched;
if (CpFirstSty(cpFound, styChar) == cpFound) {
/* It is on a Kanji boundary. We really found it. */
return (cpFound);
}
else {
/* The last character did not match, try again
excluding the last byte match. */
cchMatched -= cbLastMatch;
cbLastMatch = 1;
fMatchedWhite = false;
goto lblNextMatch;
}
#else
cpMatchLim = vcpFetch+ichDoc - (fMatchedWhite ? 1 : 0);
return vcpFetch + ichDoc - cchMatched;
#endif
}}
#ifdef DBCS
if (cpFetchSave + ichDoc >= cpMacSearch)
#else
if (vcpFetch + ichDoc >= cpMacSearch)
#endif
{{ /* Not found */
if(fMatchedWhite && szSearch[ichPat+2] == '\0')
{ /* Found it */
#ifdef DBCS
cpMatchLim = cpFetchSave + ichDoc;
cpFound = cpFetchSave + ichDoc - cchMatched;
if (CpFirstSty(cpFound, styChar) == cpFound) {
/* It is on a Kanji boundary, We really found it. */
return (cpFound);
}
else {
/* The last character did not match, try again
excluding the last byte match. */
cchMatched -= cbLastMatch;
cbLastMatch = 1;
fMatchedWhite = false;
goto lblNextMatch;
}
#else
cpMatchLim = vcpFetch+ichDoc;
return vcpFetch + ichDoc - cchMatched;
#endif
}
else
return cpNil;
}}
#if defined(DBCS)
if (ichDoc + cbLastMatch - 1 >= ccpFetchSave)
#else
if (ichDoc >= vccpFetch)
#endif
{ /* Need more cp's */
{{
#ifndef NOLA /* no look ahead */
/* check if abort search */
if (FAbort())
{
fAbortSearch = TRUE;
return cpNil;
}
#endif /* NOLA */
/* FetchCp(docNil, cpNil, 0, fcmChars + fcmNoExpand); */
/* we changed from a sequential fetch to a random fetch because a resize of the
window may cause another FetchCp before we reach here */
#ifdef DBCS
FetchCp(docCur, cpFetchNext, 0, fcmChars + fcmNoExpand);
cpFetchSave = vcpFetch;
#ifdef JAPAN //raid 4709 bug fix
bltbyte(vpchFetch, rgchT, ccpFetchSave =
((vccpFetch > (dcpAvgSent-2)) ? (dcpAvgSent-2) : vccpFetch));
{
int inc;
BOOL bDBCSBreak = FALSE;
typeCP saveVcpFetch;
for(inc = 0;inc < ccpFetchSave;inc++) {
if(IsDBCSLeadByte((BYTE)rgchT[inc])) {
inc++;
if(inc >= ccpFetchSave) {
bDBCSBreak = TRUE;
break;
}
}
}
if(bDBCSBreak) {
saveVcpFetch = vcpFetch;
FetchCp(docCur, cpFetchSave + ccpFetchSave,
0, fcmChars + fcmNoExpand);
bltbyte(vpchFetch, rgchT+ccpFetchSave,1);
ccpFetchSave++;
vcpFetch = saveVcpFetch;
}
}
#else //JAPAN
bltbyte(vpchFetch, rgchT,
ccpFetchSave = ((vccpFetch > dcpAvgSent) ?
dcpAvgSent : vccpFetch));
if (vccpFetch > dcpAvgSent) {
int inc;
fDBCS = 0;
for(inc = 0;inc < dcpAvgSent;inc++) {
if(fDBCS)
fDBCS = 0;
else
fDBCS = IsDBCSLeadByte((BYTE)rgchT[inc]);
}
if(fDBCS)
ccpFetchSave--;
fDBCS = 0;
}
#endif //JAPAN
cpFetchNext = cpFetchSave + ccpFetchSave;
#else //DBCS
FetchCp(docCur, cpFetchNext, 0, fcmChars + fcmNoExpand);
cpFetchNext = vcpFetch + vccpFetch;
#endif //DBCS
ichDoc = 0;
}}
continue;
}
#ifdef DBCS
ch = pchFetchSave[ichDoc++];
#if defined(JAPAN) || defined(KOREA) /*t-Yoshio*/
if(IsDBCSLeadByte((BYTE)ch))
{
chNext = pchFetchSave[ichDoc++];
cbLastMatch = 2;
}
else
{
chNext = pchFetchSave[ichDoc];
cbLastMatch = 1;
}
#else
cbLastMatch = 1;
#endif /*JAPAN*/
#else
ch = vpchFetch[ichDoc++];
#endif
if(!fSpecialMatch)
{
/* NOTE: this is just ChLower() brought in-line for speed */
#ifdef DBCS
if( fDBCS )
#if defined(KOREA)
{
if(!fSearchCase)
if(ch >= 'A' && ch <= 'Z') ch += 'a' - 'A';
else if (ch == 0xA3 && (chNext >= 0xC1 && chNext <= 0xDA))
chNext = 0x20 + chNext;
fDBCS = FALSE;
}
#else
fDBCS = FALSE;
#endif
else
if(!fSearchCase)
#if defined(TAIWAN) || defined(PRC)
if ( !( fDBCS = IsDBCSLeadByte( ch )))
#endif
{ /* avoid proc call for common cases */
if(ch >= 'A' && ch <= 'Z') ch += 'a' - 'A';
#ifdef JAPAN /*t-Yoshio*/
if(ch == 0x82 && (chNext >= 0x60 && chNext <= 0x79))
chNext = 0x21 + chNext;
#elif defined(KOREA)
else if(ch == 0xA3 && (chNext >= 0xC1 && chNext <= 0xDA))
chNext = 0x20 + chNext;
#else
else if(ch < 'a' || ch > 'z') ch = ChLower(ch);
#endif
}
#else
if(!fSearchCase)
{ /* avoid proc call for common cases */
if(ch >= 'A' && ch <= 'Z') ch += 'a' - 'A';
else if(ch < 'a' || ch > 'z') ch = ChLower(ch);
}
#endif
#ifdef JAPAN /*t-Yoshio*/
if(!fSearchDist)
{
char han_str[3];
han_str[0] = ch;han_str[1] = '\0';han_str[2] = '\0';
if(IsDBCSLeadByte((BYTE)ch))
{
if(szSearch[ichPat] == ch && szSearch[ichPat+1] == chNext)
{
ichPat+=2;
fMatched = true;
}
else
fMatched = false;
}
else
{
if(ch >= 0xca && ch <= 0xce)
{
if(!myIsSonant(szSearch[ichPat],szSearch[ichPat+1]))
han_str[1] = '\0';
else if(chNext == 0xde || chNext == 0xdf )
{
han_str[1] = chNext;
han_str[2] = '\0';
cbLastMatch = 2;
ichDoc++;
}
else
han_str[1] = '\0';
}
else if(ch >= 0xa6 && ch <= 0xc4)
{
if(!myIsSonant(szSearch[ichPat],szSearch[ichPat+1]))
han_str[1] = '\0';
else if(chNext == 0xde )
{
han_str[1] = chNext;
han_str[2] = '\0';
cbLastMatch = 2;
ichDoc++;
}
else
han_str[1] = '\0';
}
else
han_str[1] = '\0';
myHantoZen(han_str,dch,3);
if(szSearch[ichPat] == dch[0] && szSearch[ichPat+1] == dch[1])
{
ichPat+=2;
fMatched = true;
}
else if(ch == chReturn || ch == chNRHFile)
fMatched = true;
else
fMatched = false;
}
}
else
{
if(IsDBCSLeadByte((BYTE)ch))
{
if(szSearch[ichPat] == ch && szSearch[ichPat+1] == chNext)
{
ichPat+=2;
fMatched = true;
}
else
fMatched = false;
}
else if(szSearch[ichPat] == ch)
{
ichPat++;
fMatched = true;
}
else if(ch == chReturn || ch == chNRHFile)
fMatched = true;
else
fMatched = false;
}
#elif defined(KOREA)
if(!fSearchDist)
{
char han_str[3];
han_str[0] = ch;han_str[1] = '\0';han_str[2] = '\0';
if(IsDBCSLeadByte((BYTE)ch))
{
if(szSearch[ichPat] == ch && szSearch[ichPat+1] == chNext)
{
ichPat+=2;
fMatched = true;
}
else
fMatched = false;
}
else
{
han_str[1] = '\0';
myHantoZen(han_str,dch,3);
if(szSearch[ichPat] == dch[0] && szSearch[ichPat+1] == dch[1])
{
ichPat+=2;
fMatched = true;
}
else if(ch == chReturn || ch == chNRHFile)
fMatched = true;
else
fMatched = false;
}
}
else
{
if(IsDBCSLeadByte((BYTE)ch))
{
if(szSearch[ichPat] == ch && szSearch[ichPat+1] == chNext)
{
ichPat+=2;
fMatched = true;
}
else
fMatched = false;
}
else if(szSearch[ichPat] == ch)
{
ichPat++;
fMatched = true;
}
else if(ch == chReturn || ch == chNRHFile)
fMatched = true;
else
fMatched = false;
}
#else
if(szSearch[ichPat] == ch)
{
ichPat++;
fMatched = true;
}
else if(ch == chReturn || ch == chNRHFile)
fMatched = true;
else
fMatched = false;
#endif
}
else
{
#if defined(JAPAN) || defined(KOREA) /*t-Yoshio*/
fMatched = J_FChMatch(ch,chNext,&ichPat,&ichDoc);
#else
fMatched = FChMatch(ch, &ichPat, true);
#endif
}
#ifdef DBCS
//#ifndef JAPAN /*t-Yoshio*/
#if !defined(JAPAN) && !defined(KOREA) /*t-Yoshio*/
fDBCS = IsDBCSLeadByte( ch );
#endif
#endif
if(fMatched)
{
#if defined(DBCS)
cchMatched += cbLastMatch;
#else
cchMatched++;
#endif
}
else
{ /* No match; try again */
#ifdef DBCS
lblNextMatch:
#endif
if ((ichDoc -= cchMatched) < 0) /* Go back # of matched chars */
{{ /* Overshot the mark */
#ifdef DBCS
FetchCp(docCur, cpFetchSave + ichDoc, 0, fcmChars + fcmNoExpand);
cpFetchSave = vcpFetch;
#ifdef JAPAN //raid 4709 bug fix
bltbyte(vpchFetch, rgchT, ccpFetchSave =
((vccpFetch > (dcpAvgSent-2)) ? (dcpAvgSent-2) : vccpFetch));
{
int inc;
BOOL bDBCSBreak = FALSE;
typeCP saveVcpFetch;
for(inc = 0;inc < ccpFetchSave;inc++) {
if(IsDBCSLeadByte((BYTE)rgchT[inc])) {
inc++;
if(inc >= ccpFetchSave) {
bDBCSBreak = TRUE;
break;
}
}
}
if(bDBCSBreak) {
saveVcpFetch = vcpFetch;
FetchCp(docCur, cpFetchSave + ccpFetchSave,
0, fcmChars + fcmNoExpand);
bltbyte(vpchFetch, rgchT+ccpFetchSave,1);
ccpFetchSave++;
vcpFetch = saveVcpFetch;
}
}
#else //JAPAN
bltbyte(vpchFetch, rgchT,
ccpFetchSave = ((vccpFetch > dcpAvgSent) ?
dcpAvgSent : vccpFetch));
if (vccpFetch > dcpAvgSent) {
int inc;
fDBCS = 0;
for(inc = 0;inc < dcpAvgSent;inc++) {
if(fDBCS)
fDBCS = 0;
else
fDBCS = IsDBCSLeadByte((BYTE)rgchT[inc]);
}
if(fDBCS)
ccpFetchSave--;
fDBCS = 0;
}
#endif //JAPAN
cpFetchNext = cpFetchSave + ccpFetchSave;
#else //DBCS
FetchCp(docCur, vcpFetch + ichDoc, 0, fcmChars + fcmNoExpand);
/* this is for the next FetchCp in this forever loop that used to depend
on a sequential fetch */
cpFetchNext = vcpFetch + vccpFetch;
#endif //DBCS
ichDoc = 0;
}}
ichPat = 0;
cchMatched = 0;
}
}
}}
/* set up in hszFlatSearch a copy of hszSearch that is all lower case.
Note that we assume the old contents of hszFlatSearch were freed.
Return True if success, False if out of memory.
*/
NEAR FMakeFlat(cch)
int cch; /*CchSz(**hszSearch)-1*/
{
CHAR *pch1;
CHAR *pch2;
hszFlatSearch = (CHAR (**) [])HAllocate(CwFromCch(cch+1));
if(FNoHeap(hszFlatSearch))
return(FALSE);
if(!fSearchCase)
{
#ifdef DBCS
for(pch1= **hszSearch, pch2 = **hszFlatSearch;*pch1!='\0';)
if( IsDBCSLeadByte(*pch1) ) {
#ifdef JAPAN /*t-Yoshio*/
if(*pch1 == 0x82 && (*(pch1+1) >= 0x60 && *(pch1+1) <= 0x79 ))
{
*pch2++ = *pch1++;
*pch2++ = 0x21 + *pch1++;
}
else
{
*pch2++ = *pch1++;
*pch2++ = *pch1++;
}
#elif defined(KOREA)
if(*pch1 == 0xA3 && (*(pch1+1) >= 0xC1 && *(pch1+1) <= 0xDA))
{
*pch2++ = *pch1++;
*pch2++ = 0x20 + *pch1++;
}
else
{
*pch2++ = *pch1++;
*pch2++ = *pch1++;
}
#else
*pch2++ = *pch1++;
*pch2++ = *pch1++;
#endif
} else
{
#if defined(JAPAN) || defined(KOREA) /*t-Yoshio*/
if(*pch1 >= 'A' && *pch1 <= 'Z')
{
*pch2 = *pch1 + 0x20; pch1++; pch2++;
}
else
*pch2++ = *pch1++;
#else
*pch2++ = ChLower(*pch1++);
#endif
}
#else
for(pch1= **hszSearch, pch2 = **hszFlatSearch;*pch1!='\0';pch1++,pch2++)
*pch2 = ChLower(*pch1);
#endif
*pch2 = '\0';
}
else
bltbyte(**hszSearch, **hszFlatSearch, cch+1);
return(TRUE);
}
/* sets the global fSpecialMatch if the more complicated character matching
code is needed */
NEAR SetSpecialMatch()
{
CHAR *pch = **hszSearch;
CHAR ch;
#ifdef DBCS
for( ch = *pch ; ch != '\0'; pch = AnsiNext(pch), ch = *pch )
#else
while((ch = *pch++) != '\0')
#endif
{
switch(ch)
{
default:
continue;
case chMatchAny:
case chPrefixMatch:
case chSpace:
case chHyphen:
fSpecialMatch = true;
return;
}
}
fSpecialMatch = false;
return;
}
/* Sets the global fParaReplace if the user wants to insert Paragraph breaks
(since special insertion code must be run). Also sets up the global
hszRealReplace to reflect any meta characters in hszReplace */
NEAR FSetParaReplace(cch)
int cch; /*CchSz(**hszReplace)*/
{
CHAR *rgch = **hszRealReplace;
int ich = 0;
CHAR ch;
CHAR chNew;
fParaReplace = false;
while((ch = rgch[ich]) != '\0')
{
#ifdef DBCS
if(IsDBCSLeadByte(ch)){
ich +=2;
continue;
}
#endif
switch(ch)
{
default:
break;
case chPrefixMatch:
switch(rgch[ich+1])
{
default:
/* just escaping the next char */
if(rgch[ich+1] == '\0')
chNew = chPrefixMatch;
else
chNew = rgch[ich+1];
break;
case chMatchNBSFile:
chNew = chNBSFile;
break;
case chMatchTab:
chNew = chTab;
break;
case chMatchNewLine:
chNew = chNewLine;
break;
case chMatchNRHFile:
chNew = chNRHFile;
break;
case chMatchSect:
chNew = chSect;
break;
case chMatchEol:
chNew = chEol;
break;
}
#ifdef CRLF
if(chNew != chEol)
bltbyte(&(rgch[ich+1]),&(rgch[ich]), cch-ich-1);
#else
bltbyte(&(rgch[ich+1]),&(rgch[ich]), cch-ich-1);
#endif /*CRLF*/
if(chNew == chEol)
{
fParaReplace = true;
#ifdef CRLF
rgch[ich++] = chReturn;
#endif /*CRLF*/
}
rgch[ich] = chNew;
break;
case chEol:
#ifdef CRLF
if(ich == 0 || rgch[ich-1] != chReturn)
/* they didn't put in a return! */
{
CHAR (**hsz)[];
hsz = (CHAR (**) [])HAllocate(CwFromCch(cch+1));
if(FNoHeap(hsz))
{
return false;
}
bltbyte(**hszRealReplace, **hsz, ich);
(**hsz)[ich] = chReturn;
bltbyte((**hszRealReplace)+ich, (**hsz)+ich+1,
cch - ich);
FreeH(hszRealReplace);
hszRealReplace = hsz;
rgch = **hszRealReplace;
cch++;
ich++;
}
#endif /*CRLF*/
fParaReplace = true;
break;
}
ich++;
}
return true;
}
NEAR WCaseCp(cp,dcp)
typeCP cp;
typeCP dcp;
{
/* Determines capitalization pattern in a piece of text. Used when doing
replace to match existing pattern. returns an int which is one of:
0 - Not initial capital
1 - Initial Capital but lower case appears later
2 - Initial Capital and no lower case in the string
Assumes a valid cp, dcp pair.
*/
int ichDoc;
FetchCp(docCur, cp, 0, fcmChars + fcmNoExpand);
if(!isupper(vpchFetch[0]))
return(0);
/* we now know there is an initial cap. Are there any lower case chars? */
for(ichDoc=1; vcpFetch+ichDoc < cp + dcp;)
{
if(ichDoc >= vccpFetch)
{
FetchCp(docNil, cpNil, 0, fcmChars + fcmNoExpand);
ichDoc = 0;
continue;
}
if(islower(vpchFetch[ichDoc++]))
return(1);
}
/* No lower case letters were found. */
return(2);
}
int
FCpValid(cp, dcp)
typeCP cp, dcp;
{
CachePara(docCur, cp);
if (vpapAbs.fGraphics)
return false;
#ifdef JAPAN /*t-Yoshio*/
if (0)
#else
if (fSearchWord)
#endif
return FWordCp(cp, dcp);
return true;
}
NEAR DestroyModeless(phDlg)
HWND * phDlg;
{
HWND hDlg = *phDlg;
*phDlg = (HWND)NULL;
vhWndMsgBoxParent = (HANDLE)NULL;
DestroyWindow(hDlg);
} /* end of DestroyModeless */
BOOL far PASCAL DialogFind( hDlg, message, wParam, lParam )
HWND hDlg; /* Handle to the dialog box */
unsigned message;
WORD wParam;
LONG lParam;
{
CHAR szBuf[257];
int cch = 0;
HANDLE hCtlFindNext = GetDlgItem(hDlg, idiFindNext);
/* This routine handles input to the Find dialog box. */
switch (message)
{
case WM_INITDIALOG:
#ifdef ENABLE /* not sure how cxEditScroll is used */
cxEditScroll = 0;
#endif
#ifdef JAPAN /*t-Yoshio*/
CheckDlgButton(hDlg, idiDistinguishDandS, fSearchDist);
#elif defined(KOREA)
//bklee CheckDlgButton(hDlg, idiDistinguishDandS, fSearchDist);
CheckDlgButton(hDlg, idiWholeWord, fSearchWord);
#else
CheckDlgButton(hDlg, idiWholeWord, fSearchWord);
#endif
CheckDlgButton(hDlg, idiMatchCase, fSearchCase);
cch = CchCopySz(**hszSearch, szBuf);
if (cch == 0)
{
EnableWindow(hCtlFindNext, false);
}
else
{
SetDlgItemText(hDlg, idiFind, (LPSTR)szBuf);
SelectIdiText(hDlg, idiFind);
}
vfDidSearch = false;
cpWall = selCur.cpLim;
return( TRUE ); /* ask windows to set focus to the first item also */
case WM_ACTIVATE:
if (wParam) /* turns active */
{
vhWndMsgBoxParent = hDlg;
}
if (vfCursorVisible)
ShowCursor(wParam);
return(FALSE); /* so that we leave the activate message to
the dialog manager to take care of setting the focus correctly */
case WM_COMMAND:
switch (wParam)
{
case idiFind:
if (HIWORD(lParam) == EN_CHANGE)
{
vfDidSearch = false;
cpWall = selCur.cpLim;
CheckEnableButton(LOWORD(lParam), hCtlFindNext);
}
break;
#ifdef JAPAN /*t-Yoshio*/
case idiDistinguishDandS :
#elif defined(KOREA)
case idiDistinguishDandS :
case idiWholeWord:
#else
case idiWholeWord:
#endif
case idiMatchCase:
CheckDlgButton(hDlg, wParam, !IsDlgButtonChecked(hDlg, wParam));
break;
case idiFindNext:
if (IsWindowEnabled(hCtlFindNext))
{
CHAR (**hszSearchT)[] ;
if (FDlgSzTooLong(hDlg, idiFind, szBuf, 257))
{
switch (idiMsgResponse(hDlg, idiFind, IDPMTTruncateSz))
{
case idiOk:
/* show truncated text to user */
SetDlgItemText(hDlg, idiFind, (LPSTR)szBuf);
break;
case idiCancel:
default:
return(TRUE);
}
}
if (FNoHeap(hszSearchT = HszCreate(szBuf)))
break;
/* fSearchForward = 1; search direction -- always forward */
PostStatusInCaption(IDSTRSearching);
StartLongOp();
FreeH(hszSearch);
hszSearch = hszSearchT;
fSearchCase = IsDlgButtonChecked(hDlg, idiMatchCase);
#ifdef JAPAN /*t-Yoshio*/
fSearchWord = 0;
fSearchDist = IsDlgButtonChecked(hDlg, idiDistinguishDandS);
#elif defined(KOREA)
//bklee fSearchDist = IsDlgButtonChecked(hDlg, idiDistinguishDandS);
fSearchDist = 1;
fSearchWord = IsDlgButtonChecked(hDlg, idiWholeWord);
#else
fSearchWord = IsDlgButtonChecked(hDlg, idiWholeWord);
#endif
EnableExcept(vhDlgFind, FALSE);
DoSearch();
EnableExcept(vhDlgFind, TRUE);
EndLongOp(vhcIBeam);
PostStatusInCaption(NULL);
}
break;
case idiCancel:
LCancelFind:
DestroyModeless(&vhDlgFind);
break;
default:
return(FALSE);
}
break;
case WM_CLOSE:
if (bInSearchReplace)
return TRUE;
goto LCancelFind;
#ifndef INEFFLOCKDOWN
case WM_NCDESTROY:
FreeProcInstance(lpDialogFind);
lpDialogFind = NULL;
/* fall through to return false */
#endif
default:
return(FALSE);
}
return(TRUE);
} /* end of DialogFind */
BOOL far PASCAL DialogChange( hDlg, message, wParam, lParam )
HWND hDlg; /* Handle to the dialog box */
unsigned message;
WORD wParam;
LONG lParam;
{
CHAR szBuf[257]; /* max 255 char + '\0' + 1 so as to detact too long string */
int cch = 0;
HANDLE hCtlFindNext = GetDlgItem(hDlg, idiFindNext);
CHAR (**hszSearchT)[];
CHAR (**hszReplaceT)[];
/* This routine handles input to the Change dialog box. */
switch (message)
{
case WM_INITDIALOG:
#ifdef ENABLE /* not sure how cxEditScroll is used */
cxEditScroll = 0;
#endif
szBuf[0] = '\0';
#ifdef JAPAN /*t-Yoshio*/
CheckDlgButton(hDlg, idiDistinguishDandS, fSearchDist);
#elif defined(KOREA)
//bklee CheckDlgButton(hDlg, idiDistinguishDandS, fSearchDist);
CheckDlgButton(hDlg, idiWholeWord, fSearchWord);
#else
CheckDlgButton(hDlg, idiWholeWord, fSearchWord);
#endif
CheckDlgButton(hDlg, idiMatchCase, fSearchCase);
cch = CchCopySz(**hszSearch, szBuf);
SetDlgItemText(hDlg, idiFind, (LPSTR)szBuf);
if (cch > 0)
{
SelectIdiText(hDlg, idiFind);
}
else
{
EnableWindow(hCtlFindNext, false);
EnableWindow(GetDlgItem(hDlg, idiChangeThenFind), false);
//EnableWindow(GetDlgItem(hDlg, idiChange), false);
EnableWindow(GetDlgItem(hDlg, idiChangeAll), false);
}
cch = CchCopySz(**hszReplace, szBuf);
SetDlgItemText(hDlg, idiChangeTo, (LPSTR)szBuf);
fChangeSel = false;
vfDidSearch = false;
SetChangeString(hDlg, selCur.cpFirst == selCur.cpLim);
cpWall = selCur.cpLim;
return( TRUE ); /* ask windows to set focus to the first item also */
case WM_ACTIVATE:
if (wParam)
{
vhWndMsgBoxParent = hDlg;
SetChangeString(hDlg, (selCur.cpFirst == selCur.cpLim) || vfDidSearch);
}
if (vfCursorVisible)
ShowCursor(wParam);
return(FALSE); /* so that we leave the activate message to
the dialog manager to take care of setting the focus correctly */
case WM_COMMAND:
switch (wParam)
{
case idiFind: /* edittext */
if (HIWORD(lParam) == EN_CHANGE)
{
vfDidSearch = false;
cpWall = selCur.cpLim;
if (!CheckEnableButton(LOWORD(lParam), hCtlFindNext))
{
EnableWindow(GetDlgItem(hDlg, idiChangeThenFind), false);
//EnableWindow(GetDlgItem(hDlg, idiChange), false);
EnableWindow(GetDlgItem(hDlg, idiChangeAll), false);
}
else
{
EnableWindow(GetDlgItem(hDlg, idiChangeThenFind), true);
//EnableWindow(GetDlgItem(hDlg, idiChange), true);
EnableWindow(GetDlgItem(hDlg, idiChangeAll), true);
}
return(TRUE);
}
else
return(FALSE);
case idiChangeTo: /* edittext */
return(FALSE);
case idiFindNext: /* Button for Find Next */
/* Windows did not check if the default button is disabled
or not, so we have to check that! */
if (!IsWindowEnabled(hCtlFindNext))
break;
//case idiChange: /* Change, and stay put */
case idiChangeThenFind: /* Change, then Find button */
case idiChangeAll: /* Button for Replace All */
if (wwCur < 0)
break;
if (FDlgSzTooLong(hDlg, idiFind, szBuf, 257))
{
switch (idiMsgResponse(hDlg, idiFind, IDPMTTruncateSz))
{
case idiOk:
/* show truncated text to user */
SetDlgItemText(hDlg, idiFind, (LPSTR)szBuf);
break;
case idiCancel:
default:
return(TRUE);
}
}
if (FNoHeap(hszSearchT = HszCreate(szBuf)))
break;
if (FDlgSzTooLong(hDlg, idiChangeTo, szBuf, 257))
{
switch (idiMsgResponse(hDlg, idiChangeTo, IDPMTTruncateSz))
{
case idiOk:
/* show truncated text to user */
SetDlgItemText(hDlg, idiChangeTo, (LPSTR)szBuf);
break;
case idiCancel:
default:
return(TRUE);
}
}
if (FNoHeap(hszReplaceT = HszCreate(szBuf)))
break;
PostStatusInCaption(IDSTRSearching);
StartLongOp();
FreeH(hszSearch);
hszSearch = hszSearchT;
FreeH(hszReplace);
hszReplace = hszReplaceT;
/* fReplConfirm = 1;*/
fSearchCase = IsDlgButtonChecked(hDlg, idiMatchCase);
#ifdef JAPAN /*t-Yoshio*/
fSearchWord = 0;
fSearchDist = IsDlgButtonChecked(hDlg, idiDistinguishDandS);
#elif defined(KOREA)
//bklee fSearchDist = IsDlgButtonChecked(hDlg, idiDistinguishDandS);
fSearchDist = 1;
fSearchWord = IsDlgButtonChecked(hDlg, idiWholeWord);
#else
fSearchWord = IsDlgButtonChecked(hDlg, idiWholeWord);
#endif
EnableExcept(vhDlgChange, FALSE);
switch (wParam)
{
case idiFindNext:
DoSearch();
break;
//case idiChange:
case idiChangeThenFind:
CmdReplace(wParam == idiChangeThenFind);
break;
case idiChangeAll:
TurnOffSel();
if (!fChangeSel)
{
fSelSave = TRUE;
selSave.cpFirst = selCur.cpFirst;
selSave.cpLim = selCur.cpLim;
selCur.cpFirst = cpMinCur;
selCur.cpLim = cpMacCur;
}
CmdReplaceAll();
fSelSave = FALSE; /* reset */
break;
default:
Assert(FALSE);
break;
}
EnableExcept(vhDlgChange, TRUE);
SetChangeString(hDlg, vfDidSearch ? true : selCur.cpFirst == selCur.cpLim);
EndLongOp(vhcIBeam);
PostStatusInCaption(NULL);
break;
#ifdef JAPAN /*t-Yoshio*/
case idiDistinguishDandS:
#elif defined(KOREA)
case idiDistinguishDandS:
case idiWholeWord:
#else
case idiWholeWord:
#endif
case idiMatchCase:
CheckDlgButton(hDlg, wParam, !IsDlgButtonChecked(hDlg, wParam));
break;
case idiCancel:
LCancelChange:
DestroyModeless(&vhDlgChange);
break;
default:
return(FALSE);
}
break;
#if WINVER < 0x300
/* Don't really need to process this */
case WM_CLOSE:
goto LCancelChange;
#endif
#ifndef INEFFLOCKDOWN
case WM_NCDESTROY:
FreeProcInstance(lpDialogChange);
lpDialogChange = NULL;
/* fall through to return false */
#endif
default:
return(FALSE);
}
return(TRUE);
} /* end of DialogChange */
NEAR SetChangeString(hDlg, fAll)
HANDLE hDlg;
int fAll;
{ /* set the last control button in CHANGE to "Change All" or "Change Selection" */
CHAR sz[256];
if (fAll == fChangeSel)
{
PchFillPchId(sz, (fAll ? IDSTRChangeAll : IDSTRChangeSel), sizeof(sz));
SetDlgItemText(hDlg, idiChangeAll, (LPSTR)sz);
fChangeSel = !fAll;
}
}
fnFindText()
{/* create dialog window only when it is not already created. */
if (!IsWindow(vhDlgFind))
{
#ifndef INEFFLOCKDOWN
if (!lpDialogFind)
if (!(lpDialogFind = MakeProcInstance(DialogFind, hMmwModInstance)))
{
WinFailure();
return;
}
#endif
vhDlgFind = CreateDialog(hMmwModInstance, MAKEINTRESOURCE(dlgFind),
hParentWw, lpDialogFind);
if (!vhDlgFind)
#ifdef WIN30
WinFailure();
#else
Error(IDPMTNoMemory);
#endif
}
else
{
SendMessage(vhDlgFind, WM_ACTIVATE, true, (LONG)NULL);
}
}
fnFindAgain()
{
register HWND hDlg = wwdCurrentDoc.wwptr;
register HWND hWndFrom;
hWndFrom = GetActiveWindow();
/* Find out where the F3 was executed from */
/* assemble hszSearch if called from Find or Change dialog box */
if (vhDlgFind || vhDlgChange)
{
if (((hDlg = vhDlgFind) && (vhDlgFind == hWndFrom ||
vhDlgFind == (HANDLE)GetWindowWord(hWndFrom, GWW_HWNDPARENT)))
||
((hDlg = vhDlgChange) && (vhDlgChange == hWndFrom ||
vhDlgChange == (HANDLE)GetWindowWord(hWndFrom, GWW_HWNDPARENT))))
{
SendMessage(hDlg, WM_COMMAND, idiFindNext, (LONG)0);
goto Out;
}
}
PostStatusInCaption(IDSTRSearching);
StartLongOp();
DoSearch();
EndLongOp(vhcIBeam);
PostStatusInCaption(NULL);
Out:
if (!IsWindowEnabled(wwdCurrentDoc.wwptr))
EnableWindow(wwdCurrentDoc.wwptr, true);
if (!IsWindowEnabled(hParentWw))
EnableWindow(hParentWw, true);
SendMessage(hParentWw, WM_ACTIVATE, true, (LONG)NULL);
} /* end of fnFindAgain */
fnReplaceText()
{/* create dialog window only when it is not already created. */
if (!IsWindow(vhDlgChange))
{
#ifndef INEFFLOCKDOWN
if (!lpDialogChange)
if (!(lpDialogChange = MakeProcInstance(DialogChange, hMmwModInstance)))
{
WinFailure();
return;
}
#endif
vhDlgChange = CreateDialog(hMmwModInstance, MAKEINTRESOURCE(dlgChange),
hParentWw, lpDialogChange);
if (!vhDlgChange)
#ifdef WIN30
WinFailure();
#else
Error(IDPMTNoMemory);
#endif
}
else
{
SendMessage(vhDlgChange, WM_ACTIVATE, true, (LONG)NULL);
}
}
/* P U T C P I N W W V E R T S R C H*/
NEAR PutCpInWwVertSrch(cp)
typeCP cp;
{
/* vertical case */
typeCP cpMac;
int ypMac;
struct EDL *pedl;
int dl;
int dlMac;
UpdateWw(wwCur, false);
dlMac = pwwdCur->dlMac - (vfSelecting ? 0 : 1);
if (dlMac <= 0)
return;
pedl = &(**(pwwdCur->hdndl))[dlMac - 1];
if (cp < pwwdCur->cpFirst ||
cp > (cpMac = pedl->cpMin + pedl->dcpMac) ||
cp == cpMac && pedl->fIchCpIncr)
{
DirtyCache(pwwdCur->cpFirst = cp);
pwwdCur->ichCpFirst = 0;
/* This call places the search cp vertically on the screen
by scrolling. */
CtrBackDypCtr( (pwwdCur->ypMac - pwwdCur->ypMin) >> 1, 2 );
#ifdef ENABLE /* no ActiveWindow concept yet */
if (pwwdCur->wwptr != ActiveWindow)
#endif
TrashWw(wwCur);
}
else
{
ypMac = pwwdCur->ypMac / 2;
/* Make sure that cp is still visible (scrolling if neccesary) */
pedl = &(**(pwwdCur->hdndl))[dl = DlFromYp(ypMac, pwwdCur)];
if (cp >= pedl->cpMin + pedl->dcpMac)
{
ScrollDownCtr( max( 1, dl ) );
TrashWw(wwCur);
UpdateWw(wwCur, false);
}
/* If cp is on bottom dl of the window and the dl is split by the
split bar, scroll down in doc by one line, to make insertion point
completely visible */
else if (cp >= pedl->cpMin & pedl->yp > ypMac)
{
ScrollDownCtr( 1 );
TrashWw(wwCur);
UpdateWw(wwCur,false);
}
}
}
#ifndef NOLA /* no look ahead */
BOOL (NEAR FAbort())
{
MSG msg;
register WORD vk_key;
register HANDLE hwndMsg;
HANDLE hwndPeek = (vhWndMsgBoxParent) ? vhWndMsgBoxParent : hParentWw;
if (PeekMessage((LPMSG)&msg, (HANDLE)NULL, WM_KEYFIRST, WM_KEYLAST, PM_NOREMOVE))
{
hwndMsg = msg.hwnd;
if ((hwndPeek == (HANDLE)GetWindowWord(hwndMsg, GWW_HWNDPARENT)) ||
(hwndMsg == hwndPeek))
{
#ifdef DBCS
// It can be true at DBCS that WM_CHAR is the last message.
//
PeekMessage((LPMSG)&msg, hwndMsg, WM_KEYFIRST,WM_KEYLAST,PM_REMOVE);
#else
GetMessage((LPMSG)&msg, hwndMsg, WM_KEYFIRST, WM_KEYLAST);
#endif
if (msg.message == WM_KEYDOWN &&
(((vk_key = msg.wParam) == VK_ESCAPE) || (vk_key == VK_CANCEL)))
{
while (true)
{
GetMessage((LPMSG)&msg, hwndMsg, WM_KEYFIRST, WM_KEYLAST);
if (msg.message == WM_KEYUP && msg.wParam == vk_key)
return(TRUE);
}
}
else if (msg.message >= WM_SYSKEYDOWN && msg.message <= WM_SYSDEADCHAR)
DispatchMessage((LPMSG)&msg);
}
}
return(FALSE);
} /* end of FAbort */
#endif /* NOLA */
BOOL (NEAR FWordCp(cp, dcp))
typeCP cp;
typeCP dcp;
{
/* sees if the word starting at cp (with dcp chars) is a separate
word. */
int ich;
/* check the start of the word */
if(cp != cp0)
{
int wbPrev;
int wbStart;
FetchCp(docCur,cp-1,0,fcmChars + fcmNoExpand);
ich = 0;
wbPrev = WbFromCh(vpchFetch[ich]);
if(vcpFetch+vccpFetch <= cp)
{
FetchCp(docCur,cp,0,fcmChars + fcmNoExpand);
ich = 0;
}
else
ich++;
#ifdef DBCS /* was in JAPAN; KenjiK '90-12-20 */
#ifndef KOREA
/* word break is meanless. */
if(!IsDBCSLeadByte(vpchFetch[ich]))
#endif
#endif
if(wbPrev == (wbStart = WbFromCh(vpchFetch[ich])))
{
if (wbPrev != wbWhite && wbStart != wbWhite)
return(false);
}
}
/* check the end of the word */
if(cp+dcp-1 != cp0)
{
int wbEnd;
int wbLim;
if(vcpFetch+vccpFetch <= cp+dcp-1 || vcpFetch > cp+dcp-1)
{
FetchCp(docCur,cp+dcp-1,0,fcmChars + fcmNoExpand);
ich = 0;
}
else
ich = (dcp-1) - (vcpFetch-cp);
wbEnd = WbFromCh(vpchFetch[ich]);
if(vcpFetch+vccpFetch <= cp+dcp)
{
FetchCp(docCur,cp+dcp,0,fcmChars + fcmNoExpand);
ich = 0;
}
else
ich++;
#ifdef DBCS /* was in JAPAN; KenjiK '90-12-20 */
#ifndef KOREA
/* word break is meanless. */
if(!IsDBCSLeadByte(vpchFetch[ich]))
#endif
#endif
if(vccpFetch != 0 && (wbEnd == (wbLim = WbFromCh(vpchFetch[ich]))))
{
if (wbEnd != wbWhite && wbLim != wbWhite)
return(false);
}
}
return(true);
}
BOOL (NEAR FChMatch(ch, pichPat, fFwd))
int ch;
int *pichPat;
BOOL fFwd;
{
int ich = *pichPat;
int chSearch = szSearch[ich];
BOOL fPrefixed = false;
BOOL fMatched = false;
#ifdef DEBUG
Assert(fSpecialMatch);
#endif /*DEBUG*/
#ifdef DBCS
Assert(fFwd);
cbLastMatch = 1; /* Unless DBCS space. */
#endif
/* NOTE: this is just ChLower() brought in-line for speed */
#ifdef DBCS
// No need to make lower char for DBCS second byte
if(!fDBCS && !fSearchCase && ch >= 'A' && ch <= 'Z' )
#else
if(!fSearchCase && ch >= 'A' && ch <= 'Z' )
#endif
ch += 'a' - 'A';
if(!fFwd && ich > 0 && szSearch[ich-1] == chPrefixMatch)
/* see if the char is prefixed by a chPrefixMatch */
{
chSearch = chPrefixMatch;
--ich;
}
for(;;)
{
switch(chSearch)
{
default:
//#ifdef JAPAN
#if defined(JAPAN) || defined(KOREA)
if(IsDBCSLeadByte(chSearch))
cbLastMatch = 2;
#endif
if(ch == chSearch)
goto GoodMatch;
else if(ch == chReturn || ch == chNRHFile)
goto EasyMatch;
break;
case chSpace:
if(ch == chSpace || ch == chNBSFile)
goto GoodMatch;
break;
case chHyphen:
if(ch == chHyphen || ch == chNRHFile || ch == chNBH)
goto GoodMatch;
break;
case chMatchAny:
if(ch == chReturn || ch == chNRHFile)
goto EasyMatch;
if(!fPrefixed || ch == chMatchAny)
goto GoodMatch;
break;
case chPrefixMatch:
if(fPrefixed)
{
if(ch == chPrefixMatch)
goto GoodMatch;
else
break;
}
else
{
chSearch = szSearch[ich+1];
if(fFwd)
++ich;
fPrefixed = true;
switch(chSearch)
{
default:
continue;
case chMatchEol:
chSearch = chEol;
continue;
case chMatchTab:
chSearch = chTab;
continue;
case chMatchWhite:
switch(ch)
{
default:
#ifdef DBCS
lblNonWhite:
#endif
if(fMatchedWhite)
{
if(fFwd)
{
if(szSearch[++ich] =='\0')
{
*pichPat = ich;
goto EasyMatch;
}
}
else
{
ich -= 1;
if(ich < 0)
{
*pichPat = ich;
goto EasyMatch;
}
}
*pichPat = ich;
fMatchedWhite = false;
chSearch = szSearch[ich];
continue;
}
break;
case chSpace:
case chReturn:
case chEol:
case chTab:
case chNBSFile:
case chNewLine:
case chSect:
fMatchedWhite = true;
goto EasyMatch;
}
break;
case chMatchNBSFile:
chSearch = chNBSFile;
continue;
case chMatchNewLine:
chSearch = chNewLine;
continue;
case chMatchNRHFile:
chSearch = chNRHFile;
continue;
case chMatchSect:
chSearch = chSect;
continue;
}
}
break;
}
fMatchedWhite = false;
return false;
}
GoodMatch:
*pichPat = ich + ((fFwd) ? 1 : (-1));
EasyMatch:
return true;
}
/* I N S E R T P A P S F O R R E P L A C E */
/* do AddRunScratch for every distinct paragraph in hszCaseReplace */
/* This is only needed when hszCaseReplace contains one or more chEols */
NEAR InsertPapsForReplace(fc)
typeFC fc;
{
int cchInsTotal = 0;
CHAR *pchTail;
CHAR *pchHead;
for(;;)
{
int cch;
pchHead = **hszCaseReplace + cchInsTotal;
pchTail = (CHAR *)index(pchHead, chEol);
if (pchTail == 0) return;
cch = pchTail - pchHead + 1; /* cch is count including chEol */
fc += cch;
cchInsTotal += cch;
AddRunScratch(&vfkpdParaIns, &vpapAbs, vppapNormal,
FParaEq(&vpapAbs, &vpapPrevIns) && vfkpdParaIns.brun != 0 ? -cchPAP : cchPAP,
fcMacPapIns = fc);
blt(&vpapAbs, &vpapPrevIns, cwPAP);
}
}
NEAR FDlgSzTooLong(hDlg, idi, pch, cchMax)
HWND hDlg;
int idi;
CHAR *pch;
int cchMax;
{
int cchGet = GetDlgItemText(hDlg, idi, (LPSTR)pch, cchMax);
*(pch+cchMax-2) = '\0'; /* just in case the string is too long */
if (cchGet > (cchMax - 2))
return(TRUE);
else
return(FALSE);
}
NEAR idiMsgResponse(hDlg, idi, idpmt)
HWND hDlg;
int idi;
int idpmt;
{
CHAR szT[cchMaxSz];
PchFillPchId(szT, idpmt, sizeof(szT));
SetFocus(GetDlgItem(hDlg, idi));
SendDlgItemMessage(hDlg, idi, EM_SETSEL, (WORD)NULL, MAKELONG(255, 32767));
return(IdPromptBoxSz(hDlg, szT, MB_OKCANCEL | MB_ICONASTERISK));
}
PostStatusInCaption(idstr)
int idstr;
{
extern HWND hParentWw;
extern CHAR szCaptionSave[];
CHAR *pchCaption = &szCaptionSave[0];
CHAR *pchLast;
int cch;
CHAR szT[256];
if (idstr == NULL)
{
/* restore the caption */
SetWindowText(hParentWw, (LPSTR)pchCaption);
}
else
{
/* save caption */
GetWindowText(hParentWw, (LPSTR)pchCaption, cchMaxFile);
/* append status message after app name */
#ifndef INTL
pchLast = pchCaption + CchSz(pchCaption) - 1;
while (pchLast-- > pchCaption)
{
if (*pchLast == ' ')
break;
}
PchFillPchId(bltbyte(pchCaption, szT, (cch = pchLast - pchCaption + 1)),
IDSTRSearching, 13);
#else
pchLast = pchCaption + CchSz(szAppName) + CchSz(szSepName) - 2;
PchFillPchId(bltbyte(pchCaption, szT, (cch = pchLast - pchCaption)),
IDSTRSearching, 13);
#endif
SetWindowText(hParentWw, (LPSTR)szT);
}
}
#if defined(JAPAN) || defined(KOREA) /*t-Yoshio*/
BOOL (NEAR J_FChMatch(ch, chNext, pichPat, pichDoc))
CHAR ch;
CHAR chNext;
int *pichPat;
int *pichDoc;
{
int ich = *pichPat;
CHAR chSearch = szSearch[ich];
CHAR chSearchNext = szSearch[ich+1];
WORD dchSearch;
BOOL fPrefixed = false;
if(!fSearchCase ) {
#ifdef JANPAN
if(ch == 0x82 && chNext >= 0x60 && chNext <= 0x79 )
chNext = 0x21 + chNext;
#else
if(ch == 0xA3 && (chNext >= 0xC1 && chNext <= 0xDA))
chNext = 0x20 + chNext;
#endif
else if( ch >= 'A' && ch <= 'Z' )
ch += 'a' - 'A';
}
for(;;) {
if( chSearch == chPrefixMatch ) {
if(fPrefixed) {
if(ch == chPrefixMatch) {
*pichPat = ich + 1;
return true;
}
break;
}
chSearch = chSearchNext;
ich++;
if(IsDBCSLeadByte(chSearch)) {
chSearchNext = szSearch[ich+1];
continue;
}
fPrefixed = true;
switch(chSearch)
{
default:
continue;
case chMatchEol:
chSearch = chEol;
break;
case chMatchTab:
chSearch = chTab;
break;
case chMatchNBSFile:
chSearch = chNBSFile;
break;
case chMatchNewLine:
chSearch = chNewLine;
break;
case chMatchNRHFile:
chSearch = chNRHFile;
break;
case chMatchSect:
chSearch = chSect;
break;
case chMatchWhite:
if(IsDBCSLeadByte((BYTE)ch)) {
#if defined(JAPAN)
if(ch == 0x81 && chNext == 0x40) {
#else
if(!fSearchDist && (ch == 0xA1 && chNext == 0xA1)) {
#endif
fMatchedWhite = true;
return true;
}
}
else if( ch == chSpace || ch == chReturn || ch == chEol ||
ch == chNBSFile || ch == chTab || ch == chNewLine || ch == chSect )
{
fMatchedWhite = true;
return true;
}
if(fMatchedWhite) {
if(szSearch[ich+1] =='\0') {
*pichPat = ich + 1;
return true;
}
*pichPat = ich++;
fMatchedWhite = false;
chSearch = szSearch[ich];
chSearchNext = szSearch[ich+1];
break;
}
#ifdef KOREA
fMatchedWhite = false;
return false;
#else
break;
#endif
}
}
if( chSearch == chMatchAny ) {
if(ch == chReturn || ch == chNRHFile)
return true;
if(!fPrefixed || ch == chMatchAny) {
*pichPat = ich + 1;
return true;
}
break;
}
if(chSearch == chSpace ) {
if(ch == chSpace || ch == chNBSFile || (ch == 0x81 && chNext == 0x40)) {
*pichPat = ich + 1;
return true;
}
break;
}
if(chSearch == chHyphen ) {
if(ch == chHyphen || ch == chNRHFile || ch == chNBH) {
*pichPat = ich + 1;
return true;
}
break;
}
if(!fSearchDist)
{
CHAR Doc[3];
CHAR Pat[3];
CHAR tmp[3];
Doc[0] = Doc[1] = Doc[2] = '\0';
Pat[0] = Pat[1] = Pat[2] = '\0';
if(IsDBCSLeadByte((WORD)chSearch)) {
Pat[0] = chSearch;
Pat[1] = chSearchNext;
ich += 2;
}
else {
tmp[0] = chSearch;
tmp[1] = tmp[2] = '\0';
if(chSearch >= 0xca && chSearch <= 0xce) {
if(chSearchNext == 0xde || chSearchNext == 0xdf ) {
tmp[1] = chNext;
ich += 1;
}
}
else if(chSearch >= 0xa6 && chSearch <= 0xc4) {
if(chSearchNext == 0xde ) {
tmp[1] = chNext;
ich += 1;
}
}
ich += 1;
myHantoZen(tmp,Pat,3);
}
if(IsDBCSLeadByte((BYTE)ch))
{
if(Pat[0] == ch && Pat[1] == chNext)
{
*pichPat = ich;
return true;
}
else
return false;
}
else {
tmp[0] = ch;
if(ch >= 0xca && ch <= 0xce) {
if(myIsSonant(Pat[0],Pat[1]) && chNext == 0xde || chNext == 0xdf ) {
tmp[1] = chNext;
cbLastMatch = 2;
*pichDoc++;
}
}
else if(ch >= 0xa6 && ch <= 0xc4) {
if(!myIsSonant(Pat[0],Pat[1]) && chNext == 0xde ) {
tmp[1] = chNext;
cbLastMatch = 2;
*pichDoc++;
}
}
myHantoZen(tmp,Doc,3);
if(Pat[0] == Doc[0] && Pat[1] == Doc[1])
{
*pichPat = ich;
return true;
}
else if(ch == chReturn || ch == chNRHFile)
return true;
else
return false;
}
return false;
}
if( chSearch == ch) {
if(IsDBCSLeadByte((BYTE)ch)) {
if(chSearchNext == chNext) {
*pichPat = ich + 2;
return true;
}
else
return false;
}
*pichPat = ich + 1;
return true;
}
else if(ch == chReturn || ch == chNRHFile)
return true;
break;
}
/*UnMatched*/
fMatchedWhite = false;
return false;
}
#endif