423 lines
11 KiB
C
423 lines
11 KiB
C
|
/*++
|
|||
|
|
*
|
|||
|
|
* WOW v1.0
|
|||
|
|
*
|
|||
|
|
* Copyright (c) 1991, Microsoft Corporation
|
|||
|
|
*
|
|||
|
|
* EDMLRARE.C
|
|||
|
|
* Win16 edit control code
|
|||
|
|
*
|
|||
|
|
* History:
|
|||
|
|
*
|
|||
|
|
* Created 28-May-1991 by Jeff Parsons (jeffpar)
|
|||
|
|
* Copied from WIN31 and edited (as little as possible) for WOW16.
|
|||
|
|
--*/
|
|||
|
|
|
|||
|
|
/****************************************************************************/
|
|||
|
|
/* edmlRare.c - Edit controls Routines Called rarely are to be */
|
|||
|
|
/* put in a seperate segment _EDMLRare. This file contains */
|
|||
|
|
/* these routines. */
|
|||
|
|
/****************************************************************************/
|
|||
|
|
|
|||
|
|
#define NO_LOCALOBJ_TAGS
|
|||
|
|
#include "user.h"
|
|||
|
|
#include "edit.h"
|
|||
|
|
|
|||
|
|
/****************************************************************************/
|
|||
|
|
/* Multi-Line Support Routines called Rarely */
|
|||
|
|
/****************************************************************************/
|
|||
|
|
|
|||
|
|
BOOL FAR PASCAL MLInsertCrCrLf(ped)
|
|||
|
|
register PED ped;
|
|||
|
|
/* effects: Inserts CR CR LF characters into the text at soft (word-wrap) line
|
|||
|
|
* breaks. CR LF (hard) line breaks are unaffected. Assumes that the text
|
|||
|
|
* has already been formatted ie. ped->chLines is where we want the line
|
|||
|
|
* breaks to occur. Note that ped->chLines is not updated to reflect the
|
|||
|
|
* movement of text by the addition of CR CR LFs. Returns TRUE if successful
|
|||
|
|
* else notify parent and return FALSE if the memory couldn't be allocated.
|
|||
|
|
*/
|
|||
|
|
{
|
|||
|
|
ICH dch;
|
|||
|
|
ICH li;
|
|||
|
|
ICH lineSize;
|
|||
|
|
/*register*/ unsigned char *pchText;
|
|||
|
|
unsigned char *pchTextNew;
|
|||
|
|
|
|||
|
|
|
|||
|
|
if (!ped->fWrap || !ped->cch)
|
|||
|
|
/* There are no soft line breaks if word-wrapping is off or if no chars
|
|||
|
|
*/
|
|||
|
|
return(TRUE);
|
|||
|
|
|
|||
|
|
/* Calc an upper bound on the number of additional characters we will be
|
|||
|
|
* adding to the text when we insert CR CR LFs.
|
|||
|
|
*/
|
|||
|
|
dch = 3 * sizeof(char) * ped->cLines;
|
|||
|
|
|
|||
|
|
if (!LocalReAlloc(ped->hText, ped->cch + dch, 0))
|
|||
|
|
{
|
|||
|
|
ECNotifyParent(ped, EN_ERRSPACE);
|
|||
|
|
return (FALSE);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ped->cchAlloc = ped->cch + dch;
|
|||
|
|
|
|||
|
|
/* Move the text up dch bytes and then copy it back down, inserting the CR
|
|||
|
|
* CR LF's as necessary.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
pchTextNew = pchText = LocalLock(ped->hText);
|
|||
|
|
pchText += dch;
|
|||
|
|
dch = 0; /* Now we will use this to keep track of how many chars we add
|
|||
|
|
to the text */
|
|||
|
|
|
|||
|
|
/* Copy the text up dch bytes to pchText. This will shift all indices in
|
|||
|
|
* ped->chLines up by dch bytes.
|
|||
|
|
*/
|
|||
|
|
LCopyStruct((LPSTR)pchTextNew, (LPSTR)pchText, ped->cch);
|
|||
|
|
|
|||
|
|
/* Now copy chars from pchText down to pchTextNew and insert CRCRLF at soft
|
|||
|
|
* line breaks.
|
|||
|
|
*/
|
|||
|
|
for (li = 0; li < ped->cLines-1; li++)
|
|||
|
|
{
|
|||
|
|
lineSize = ped->chLines[li+1]-ped->chLines[li];
|
|||
|
|
LCopyStruct((LPSTR)pchText, (LPSTR)pchTextNew, lineSize);
|
|||
|
|
pchTextNew += lineSize;
|
|||
|
|
pchText += lineSize;
|
|||
|
|
/* If last character in newly copied line is not a line feed, then we
|
|||
|
|
* need to add the CR CR LF triple to the end
|
|||
|
|
*/
|
|||
|
|
if (*(PSTR)(pchTextNew-1) != 0x0A)
|
|||
|
|
{
|
|||
|
|
*pchTextNew++ = 0x0D;
|
|||
|
|
*pchTextNew++ = 0x0D;
|
|||
|
|
*pchTextNew++ = 0x0A;
|
|||
|
|
dch += 3;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/* Now move the last line up. It won't have any line breaks in it... */
|
|||
|
|
LCopyStruct((LPSTR)pchText, (LPSTR)pchTextNew,
|
|||
|
|
ped->cch-ped->chLines[ped->cLines-1]);
|
|||
|
|
|
|||
|
|
LocalUnlock(ped->hText);
|
|||
|
|
|
|||
|
|
/* Update number of characters in text handle */
|
|||
|
|
ped->cch += dch;
|
|||
|
|
|
|||
|
|
if (dch)
|
|||
|
|
/*
|
|||
|
|
* So that the next time we do anything with the text, we can strip the
|
|||
|
|
* CRCRLFs
|
|||
|
|
*/
|
|||
|
|
ped->fStripCRCRLF = TRUE;
|
|||
|
|
|
|||
|
|
return((dch != 0));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
void FAR PASCAL MLStripCrCrLf(ped)
|
|||
|
|
register PED ped;
|
|||
|
|
/* effects: Strips the CR CR LF character combination from the text. This
|
|||
|
|
* shows the soft (word wrapped) line breaks. CR LF (hard) line breaks are
|
|||
|
|
* unaffected.
|
|||
|
|
*/
|
|||
|
|
{
|
|||
|
|
register unsigned char *pchSrc;
|
|||
|
|
unsigned char *pchDst;
|
|||
|
|
unsigned char *pchLast;
|
|||
|
|
|
|||
|
|
if (ped->cch)
|
|||
|
|
{
|
|||
|
|
pchSrc = pchDst = LocalLock(ped->hText);
|
|||
|
|
pchLast = pchSrc + ped->cch;
|
|||
|
|
while (pchSrc < pchLast)
|
|||
|
|
{
|
|||
|
|
if (*(int *)pchSrc != 0x0D0D)
|
|||
|
|
*pchDst++ = *pchSrc++;
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
pchSrc += 3;
|
|||
|
|
ped->cch = ped->cch - 3;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
LocalUnlock(ped->hText);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
void FAR PASCAL MLSetHandleHandler(ped, hNewText)
|
|||
|
|
register PED ped;
|
|||
|
|
HANDLE hNewText;
|
|||
|
|
/* effects: Sets the ped to contain the given handle.
|
|||
|
|
*/
|
|||
|
|
{
|
|||
|
|
ICH newCch;
|
|||
|
|
|
|||
|
|
ped->cch = ped->cchAlloc = LocalSize(ped->hText = hNewText);
|
|||
|
|
if (ped->cch)
|
|||
|
|
{
|
|||
|
|
/* We have to do it this way in case the app gives us a zero size
|
|||
|
|
handle */
|
|||
|
|
ped->cch = lstrlen((LPSTR)LocalLock(ped->hText));
|
|||
|
|
LocalUnlock(ped->hText);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/* Empty the undo buffer since the text will be in an inconsistant state.
|
|||
|
|
*/
|
|||
|
|
ECEmptyUndo(ped);
|
|||
|
|
|
|||
|
|
newCch = (ICH)(ped->cch + CCHALLOCEXTRA);
|
|||
|
|
/* We do this LocalReAlloc in case the app changed the size of the handle */
|
|||
|
|
if (LocalReAlloc(ped->hText, newCch, 0))
|
|||
|
|
ped->cchAlloc = newCch;
|
|||
|
|
|
|||
|
|
ped->fDirty = FALSE;
|
|||
|
|
|
|||
|
|
MLStripCrCrLf(ped);
|
|||
|
|
MLBuildchLines(ped,0,0,FALSE);
|
|||
|
|
|
|||
|
|
/* Reset caret and selections since the text could have changed causing
|
|||
|
|
* these to be out of range.
|
|||
|
|
*/
|
|||
|
|
ped->xOffset = ped->screenStart = ped->ichMinSel = ped->ichMaxSel = 0;
|
|||
|
|
ped->iCaretLine = ped->ichCaret = 0;
|
|||
|
|
|
|||
|
|
SetScrollPos(ped->hwnd, SB_VERT, 0, TRUE);
|
|||
|
|
SetScrollPos(ped->hwnd, SB_HORZ, 0, TRUE);
|
|||
|
|
|
|||
|
|
/* We will always redraw the text whether or not the insert was successful
|
|||
|
|
* since we may set to null text. Also, since PaintHandler checks the redraw
|
|||
|
|
* flag, we won't bother to check it here.
|
|||
|
|
*/
|
|||
|
|
InvalidateRect(ped->hwnd, (LPRECT)NULL, TRUE);
|
|||
|
|
UpdateWindow(ped->hwnd);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
LONG FAR PASCAL MLGetLineHandler(ped, lineNumber, maxCchToCopy, lpBuffer)
|
|||
|
|
register PED ped;
|
|||
|
|
WORD lineNumber;
|
|||
|
|
ICH maxCchToCopy;
|
|||
|
|
LPSTR lpBuffer;
|
|||
|
|
/* effects: Copies maxCchToCopy bytes of line lineNumber to the buffer
|
|||
|
|
* lpBuffer. The string is not zero terminated.
|
|||
|
|
*/
|
|||
|
|
{
|
|||
|
|
PSTR pText;
|
|||
|
|
|
|||
|
|
if (lineNumber > ped->cLines-1)
|
|||
|
|
return(0L);
|
|||
|
|
|
|||
|
|
maxCchToCopy = umin(MLLineLength(ped, lineNumber), maxCchToCopy);
|
|||
|
|
|
|||
|
|
if (maxCchToCopy)
|
|||
|
|
{
|
|||
|
|
pText = (PSTR)(LocalLock(ped->hText) + ped->chLines[lineNumber]);
|
|||
|
|
LCopyStruct((LPSTR)pText, (LPSTR)lpBuffer, maxCchToCopy);
|
|||
|
|
LocalUnlock(ped->hText);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return(maxCchToCopy);
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
ICH FAR PASCAL MLLineIndexHandler(ped, iLine)
|
|||
|
|
register PED ped;
|
|||
|
|
register int iLine;
|
|||
|
|
/* effects: This function returns the number of character positions that occur
|
|||
|
|
* preceeding the first char in a given line.
|
|||
|
|
*/
|
|||
|
|
{
|
|||
|
|
if (iLine == -1)
|
|||
|
|
iLine = ped->iCaretLine;
|
|||
|
|
return(iLine < ped->cLines ? ped->chLines[iLine] : -1);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
ICH FAR PASCAL MLLineLengthHandler(ped, ich)
|
|||
|
|
register PED ped;
|
|||
|
|
ICH ich;
|
|||
|
|
/* effects: if ich = -1, return the length of the lines containing the current
|
|||
|
|
* selection but not including the selection. Otherwise, return the length of
|
|||
|
|
* the line containing ich.
|
|||
|
|
*/
|
|||
|
|
{
|
|||
|
|
ICH il1, il2;
|
|||
|
|
|
|||
|
|
if (ich != 0xFFFF)
|
|||
|
|
return(MLLineLength(ped, MLIchToLineHandler(ped, ich)));
|
|||
|
|
|
|||
|
|
/* Find length of lines corresponding to current selection */
|
|||
|
|
il1 = MLIchToLineHandler(ped, ped->ichMinSel);
|
|||
|
|
il2 = MLIchToLineHandler(ped, ped->ichMaxSel);
|
|||
|
|
if (il1 == il2)
|
|||
|
|
return(MLLineLength(ped, il1) - (ped->ichMaxSel - ped->ichMinSel));
|
|||
|
|
|
|||
|
|
return(ped->ichMinSel - ped->chLines[il1] +
|
|||
|
|
MLLineLength(ped, il2) - (ped->ichMaxSel - ped->chLines[il2]));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
void FAR PASCAL MLSetSelectionHandler(ped, ichMinSel, ichMaxSel)
|
|||
|
|
register PED ped;
|
|||
|
|
ICH ichMinSel;
|
|||
|
|
ICH ichMaxSel;
|
|||
|
|
/*
|
|||
|
|
* effects: Sets the selection to the points given and puts the cursor at
|
|||
|
|
* ichMaxSel.
|
|||
|
|
*/
|
|||
|
|
{
|
|||
|
|
register HDC hdc;
|
|||
|
|
|
|||
|
|
if (ichMinSel == 0xFFFF)
|
|||
|
|
/* Set no selection if we specify -1
|
|||
|
|
*/
|
|||
|
|
ichMinSel = ichMaxSel = ped->ichCaret;
|
|||
|
|
|
|||
|
|
/* Since these are unsigned, we don't check if they are greater than 0.
|
|||
|
|
*/
|
|||
|
|
ichMinSel = umin(ped->cch,ichMinSel);
|
|||
|
|
ichMaxSel = umin(ped->cch,ichMaxSel);
|
|||
|
|
|
|||
|
|
/* Set the caret's position to be at ichMaxSel.
|
|||
|
|
*/
|
|||
|
|
ped->ichCaret = ichMaxSel;
|
|||
|
|
ped->iCaretLine = MLIchToLineHandler(ped, ped->ichCaret);
|
|||
|
|
|
|||
|
|
hdc = ECGetEditDC(ped,FALSE);
|
|||
|
|
MLChangeSelection(ped, hdc, ichMinSel, ichMaxSel);
|
|||
|
|
|
|||
|
|
MLSetCaretPosition(ped,hdc);
|
|||
|
|
ECReleaseEditDC(ped,hdc,FALSE);
|
|||
|
|
|
|||
|
|
MLEnsureCaretVisible(ped);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
** MLSetTabStops(ped, nTabPos, lpTabStops)
|
|||
|
|
**
|
|||
|
|
** This sets the tab stop positions set by the App by sending
|
|||
|
|
** a EM_SETTABSTOPS message.
|
|||
|
|
**
|
|||
|
|
** nTabPos : Number of tab stops set by the caller
|
|||
|
|
** lpTabStops: array of tab stop positions in Dialog units.
|
|||
|
|
**
|
|||
|
|
** Returns:
|
|||
|
|
** TRUE if successful
|
|||
|
|
** FALSE if memory allocation error.
|
|||
|
|
**/
|
|||
|
|
|
|||
|
|
BOOL FAR PASCAL MLSetTabStops(ped, nTabPos, lpTabStops)
|
|||
|
|
|
|||
|
|
PED ped;
|
|||
|
|
int nTabPos;
|
|||
|
|
LPINT lpTabStops;
|
|||
|
|
|
|||
|
|
{
|
|||
|
|
int * pTabStops;
|
|||
|
|
|
|||
|
|
/* Check if tab positions already exist */
|
|||
|
|
if (!ped -> pTabStops)
|
|||
|
|
{
|
|||
|
|
/* Check if the caller wants the new tab positions */
|
|||
|
|
if (nTabPos)
|
|||
|
|
{
|
|||
|
|
/* Allocate the array of tab stops */
|
|||
|
|
if(!(pTabStops = (int *)LocalAlloc(LPTR, (nTabPos + 1)*sizeof(int))))
|
|||
|
|
return(FALSE);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
return(TRUE); /* No stops then and no stops now! */
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
/* Check if the caller wants the new tab positions */
|
|||
|
|
if(nTabPos)
|
|||
|
|
{
|
|||
|
|
/* Check if the number of tab positions is different */
|
|||
|
|
if (ped->pTabStops[0] != nTabPos)
|
|||
|
|
{
|
|||
|
|
/* Yes! So ReAlloc to new size */
|
|||
|
|
if(!(pTabStops = (int *)LocalReAlloc((HANDLE)ped->pTabStops,
|
|||
|
|
(nTabPos + 1) * sizeof(int), LPTR)))
|
|||
|
|
return(FALSE);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
pTabStops = ped->pTabStops;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
/* Caller wants to remove all the tab stops; So, release */
|
|||
|
|
if (LocalFree((HANDLE)ped->pTabStops))
|
|||
|
|
return(FALSE); /* Failure */
|
|||
|
|
ped->pTabStops = NULL;
|
|||
|
|
return(TRUE);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/* Copy the new tab stops onto the tab stop array after converting the
|
|||
|
|
* dialog co-ordinates into the pixel co-ordinates
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
ped -> pTabStops = pTabStops;
|
|||
|
|
*pTabStops++ = nTabPos; /* First element contains the count */
|
|||
|
|
while(nTabPos--)
|
|||
|
|
{
|
|||
|
|
/* aveCharWidth must be used instead of cxSysCharWidth.
|
|||
|
|
* Fix for Bug #3871 --SANKAR-- 03/14/91
|
|||
|
|
*/
|
|||
|
|
*pTabStops++ = MultDiv(*lpTabStops++, ped->aveCharWidth, 4);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return(TRUE);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
BOOL FAR PASCAL MLUndoHandler(ped)
|
|||
|
|
register PED ped;
|
|||
|
|
/* effects: Handles Undo for multiline edit controls. */
|
|||
|
|
{
|
|||
|
|
HANDLE hDeletedText = ped->hDeletedText;
|
|||
|
|
BOOL fDelete = (BOOL)(ped->undoType & UNDO_DELETE);
|
|||
|
|
WORD cchDeleted = ped->cchDeleted;
|
|||
|
|
WORD ichDeleted = ped->ichDeleted;
|
|||
|
|
|
|||
|
|
if (ped->undoType == UNDO_NONE)
|
|||
|
|
/* No undo... */
|
|||
|
|
return(FALSE);
|
|||
|
|
|
|||
|
|
ped->hDeletedText = NULL;
|
|||
|
|
ped->cchDeleted = 0;
|
|||
|
|
ped->ichDeleted = -1;
|
|||
|
|
ped->undoType &= ~UNDO_DELETE;
|
|||
|
|
|
|||
|
|
if (ped->undoType == UNDO_INSERT)
|
|||
|
|
{
|
|||
|
|
ped->undoType = UNDO_NONE;
|
|||
|
|
/* Set the selection to the inserted text */
|
|||
|
|
MLSetSelectionHandler(ped, ped->ichInsStart, ped->ichInsEnd);
|
|||
|
|
ped->ichInsStart = ped->ichInsEnd = -1;
|
|||
|
|
/* Now send a backspace to delete and save it in the undo buffer...
|
|||
|
|
*/
|
|||
|
|
MLCharHandler(ped, VK_BACK, NOMODIFY);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (fDelete)
|
|||
|
|
{
|
|||
|
|
/* Insert deleted chars */
|
|||
|
|
/* Set the selection to the inserted text */
|
|||
|
|
MLSetSelectionHandler(ped, ichDeleted, ichDeleted);
|
|||
|
|
MLInsertText(ped, GlobalLock(hDeletedText), cchDeleted, FALSE);
|
|||
|
|
GlobalUnlock(hDeletedText);
|
|||
|
|
GlobalFree(hDeletedText);
|
|||
|
|
MLSetSelectionHandler(ped, ichDeleted, ichDeleted+cchDeleted);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return(TRUE);
|
|||
|
|
}
|
|||
|
|
|