mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2760 lines
85 KiB
2760 lines
85 KiB
/************************************************************/
|
|
/* 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
|
|
|
|
|
|
|