windows-xp/Source/XPSP1/NT/shell/comctl32/v6/editml.c

#include "ctlspriv.h"
#pragma hdrstop
#include "usrctl32.h"
#include "edit.h"


//---------------------------------------------------------------------------//

//
// Number of lines to bump when reallocating index buffer
//
#define LINEBUMP 32

//
// Used for ML scroll updates
//
#define ML_REFRESH  0xffffffff


//---------------------------------------------------------------------------//
//
// Forwards
//
ICH  EditML_Line(PED, ICH);
VOID EditML_ShiftchLines(PED, ICH, int);
VOID EditML_Char(PED, DWORD, int);
VOID EditML_MouseMotion(PED, UINT, UINT, LPPOINT);
BOOL EditML_EnsureCaretVisible(PED);
VOID EditML_DrawText(PED, HDC, ICH, ICH, BOOL);
BOOL EditML_InsertCrCrLf(PED);
VOID EditML_StripCrCrLf(PED);
VOID EditML_SetHandle(PED, HANDLE);
LONG EditML_GetLine(PED, ICH, ICH, LPSTR);
ICH  EditML_LineIndex(PED, ICH);
ICH  EditML_LineLength(PED, ICH);
VOID EditML_SetSelection(PED, BOOL, ICH, ICH);
BOOL EditML_SetTabStops(PED, int, LPINT);
BOOL EditML_Undo(PED);
LONG EditML_Create(PED, LPCREATESTRUCT);


//---------------------------------------------------------------------------//
__inline void EditML_SanityCheck(PED ped)
{
    UNREFERENCED_PARAMETER(ped);    // For free build

    UserAssert(ped->cch >= ped->chLines[ped->cLines - 1]);
}


//---------------------------------------------------------------------------//
// 
// EditML_GetLineWidth
// 
// Returns the max width in a line.  Edit_TabTheTextOut() ensures that max
// width won't overflow.
//
UINT EditML_GetLineWidth(HDC hdc, LPSTR lpstr, int nCnt, PED ped)
{
    return Edit_TabTheTextOut(hdc, 0, 0, 0, 0, lpstr, nCnt, 0, ped, 0, ECT_CALC, NULL);
}


//---------------------------------------------------------------------------//
//
// EditML_Size
// 
// Handles resizing of the edit control window and updating thereof.
// 
// Sets the edit field's formatting area given the passed in "client area".
// We fudge it if it doesn't seem reasonable.
// 
VOID EditML_Size(PED ped, BOOL fRedraw)
{
    //
    // Calculate the # of lines we can fit in our rectangle.
    //
    ped->ichLinesOnScreen = (ped->rcFmt.bottom - ped->rcFmt.top) / ped->lineHeight;

    //
    // Make the format rectangle height an integral number of lines
    //
    ped->rcFmt.bottom = ped->rcFmt.top + ped->ichLinesOnScreen * ped->lineHeight;

    //
    // Rebuild the line array
    //
    if (ped->fWrap) 
    {
        EditML_BuildchLines(ped, 0, 0, FALSE, NULL, NULL);
        EditML_UpdateiCaretLine(ped);
    } 
    else 
    {
        EditML_Scroll(ped, TRUE,  ML_REFRESH, 0, fRedraw);
        EditML_Scroll(ped, FALSE, ML_REFRESH, 0, fRedraw);
    }
}


//---------------------------------------------------------------------------//
//
// EditML_CalcXOffset
// 
// Calculates the horizontal offset (indent) required for centered
// and right justified lines.
//
int EditML_CalcXOffset(PED ped, HDC hdc, int lineNumber)
{
    PSTR pText;
    ICH lineLength;
    ICH lineWidth;

    if (ped->format == ES_LEFT)
    {
        return 0;
    }

    lineLength = EditML_Line(ped, lineNumber);

    if (lineLength) 
    {
        pText = Edit_Lock(ped) + ped->chLines[lineNumber] * ped->cbChar;
        hdc = Edit_GetDC(ped, TRUE);
        lineWidth = EditML_GetLineWidth(hdc, pText, lineLength, ped);
        Edit_ReleaseDC(ped, hdc, TRUE);
        Edit_Unlock(ped);
    } 
    else 
    {
        lineWidth = 0;
    }

    //
    // If a SPACE or a TAB was eaten at the end of a line by EditML_BuildchLines
    // to prevent a delimiter appearing at the begining of a line, the
    // the following calculation will become negative causing this bug.
    // So, now, we take zero in such cases.
    // Fix for Bug #3566 --01/31/91-- SANKAR --
    //
    lineWidth = max(0, (int)(ped->rcFmt.right-ped->rcFmt.left-lineWidth));

    if (ped->format == ES_CENTER)
    {
        return (lineWidth / 2);
    }

    if (ped->format == ES_RIGHT) 
    {
        //
        // Subtract 1 so that the 1 pixel wide cursor will be in the visible
        // region on the very right side of the screen.
        //
        return max(0, (int)(lineWidth-1));
    }

    return 0;
}


//---------------------------------------------------------------------------//
//
// Edit_MoveSelection AorW
//
// Moves the selection character in the direction indicated. Assumes
// you are starting at a legal point, we decrement/increment the ich. Then,
// This decrements/increments it some more to get past CRLFs...
//
ICH Edit_MoveSelection(PED ped, ICH ich, BOOL fLeft)
{

    if (fLeft && ich > 0) 
    {
        //
        // Move left
        //
        ich = Edit_PrevIch( ped, NULL, ich );
        if (ich) 
        {
            if (ped->fAnsi) 
            {
                LPSTR pText;

                //
                // Check for CRLF or CRCRLF
                //
                pText = Edit_Lock(ped) + ich;

                //
                // Move before CRLF or CRCRLF
                //
                if (*(WORD UNALIGNED *)(pText - 1) == 0x0A0D) 
                {
                    ich--;
                    if (ich && *(pText - 2) == 0x0D)
                        ich--;
                }

                Edit_Unlock(ped);
            } 
            else 
            {
                LPWSTR pwText;

                //
                // Check for CRLF or CRCRLF
                //
                pwText = (LPWSTR)Edit_Lock(ped) + ich;

                //
                // Move before CRLF or CRCRLF
                //
                if (*(pwText - 1) == 0x0D && *pwText == 0x0A) 
                {
                    ich--;
                    if (ich && *(pwText - 2) == 0x0D)
                        ich--;
                }

                Edit_Unlock(ped);
            }
        }
    } 
    else if (!fLeft && ich < ped->cch) 
    {
        //
        // Move right.
        //
        ich = Edit_NextIch( ped, NULL, ich );
        if (ich < ped->cch) 
        {
            if (ped->fAnsi) 
            {
                LPSTR pText;
                pText = Edit_Lock(ped) + ich;

                //
                // Move after CRLF
                //
                if (*(WORD UNALIGNED *)(pText - 1) == 0x0A0D)
                {
                    ich++;
                }
                else 
                {
                    //
                    // Check for CRCRLF
                    //
                    if (ich && *(WORD UNALIGNED *)pText == 0x0A0D && *(pText - 1) == 0x0D)
                    {
                        ich += 2;
                    }
                }

                Edit_Unlock(ped);
            } 
            else 
            {
                LPWSTR pwText;
                pwText = (LPWSTR)Edit_Lock(ped) + ich;

                //
                // Move after CRLF
                //
                if (*(pwText - 1) == 0x0D && *pwText == 0x0A)
                {
                    ich++;
                }
                else 
                {
                    //
                    // Check for CRCRLF
                    //
                    if (ich && *(pwText - 1) == 0x0D && *pwText == 0x0D &&
                            *(pwText + 1) == 0x0A)
                    {
                        ich += 2;
                    }
                }

                Edit_Unlock(ped);
            }
        }
    }

    return ich;
}


//---------------------------------------------------------------------------//
//
// Edit_MoveSelectionRestricted AorW
// 
// Moves the selection like Edit_MoveSelection, but also obeys limitations
// imposed by some languages such as Thai, where the cursor cannot stop
// between a character and it's attached vowel or tone marks.
//
// Only called if the language pack is loaded.
//
ICH Edit_MoveSelectionRestricted(PED ped, ICH ich, BOOL fLeft)
{
    PSTR pText;
    HDC  hdc;
    ICH  ichResult;

    pText = Edit_Lock(ped);
    hdc = Edit_GetDC(ped, TRUE);
    ichResult = ped->pLpkEditCallout->EditMoveSelection((PED0)ped, hdc, pText, ich, fLeft);
    Edit_ReleaseDC(ped, hdc, TRUE);
    Edit_Unlock(ped);

    return ichResult;
}


//---------------------------------------------------------------------------//
//
// EditML_SetCaretPosition AorW
//
// If the window has the focus, find where the caret belongs and move
// it there.
//
VOID EditML_SetCaretPosition(PED ped, HDC hdc)
{
    POINT position;
    BOOL prevLine;
    int  x = -20000;
    int  y = -20000;

    //
    // We will only position the caret if we have the focus since we don't want
    // to move the caret while another window could own it.
    //
    if (!ped->fFocus || !IsWindowVisible(ped->hwnd))
    {
         return;
    }

    //
    // Find the position of the caret
    //
    if (!ped->fCaretHidden &&
        ((ICH) ped->iCaretLine >= ped->ichScreenStart) &&
        ((ICH) ped->iCaretLine <  (ped->ichScreenStart + ped->ichLinesOnScreen))) 
    {
        RECT rcRealFmt;

        if (ped->f40Compat)
        {
            GetClientRect(ped->hwnd, &rcRealFmt);
            IntersectRect(&rcRealFmt, &rcRealFmt, &ped->rcFmt);
        } 
        else 
        {
            CopyRect(&rcRealFmt, &ped->rcFmt);
        }

        if (ped->cLines - 1 != ped->iCaretLine && ped->ichCaret == ped->chLines[ped->iCaretLine + 1]) 
        {
            prevLine = TRUE;
        } 
        else 
        {
            prevLine = FALSE;
        }

        EditML_IchToXYPos(ped, hdc, ped->ichCaret, prevLine, &position);

        if ( (position.y >= rcRealFmt.top) &&
             (position.y <= rcRealFmt.bottom - ped->lineHeight)) 
        {
            int xPos = position.x;
            int cxCaret;
 
            SystemParametersInfo(SPI_GETCARETWIDTH, 0, (LPVOID)&cxCaret, 0);

            if (ped->fWrap ||
                ((xPos > (rcRealFmt.left - cxCaret)) &&
                 (xPos <= rcRealFmt.right))) 
            {
                //
                // Make sure the caret is in the visible region if word
                // wrapping. This is so that the caret will be visible if the
                // line ends with a space.
                //
                x = max(xPos, rcRealFmt.left);
                x = min(x, rcRealFmt.right - cxCaret);
                y = position.y;
            }
        }
    }

    if (ped->pLpkEditCallout) 
    {
        SetCaretPos(x + ped->iCaretOffset, y);
    } 
    else 
    {
        SetCaretPos(x, y);
    }

    //
    // FE_IME : EditML_SetCaretPosition -- ImmSetCompositionWindow(CFS_RECT)
    //
    if (g_fIMMEnabled && ImmIsIME(GetKeyboardLayout(0))) 
    {
        if (x != -20000 && y != -20000) 
        {
            Edit_ImmSetCompositionWindow(ped, x, y);
        }
    }
}


//---------------------------------------------------------------------------//
//
// EditML_Line
//
// Returns the length of the line (cch) given by lineNumber ignoring any
// CRLFs in the line.
//
ICH EditML_Line(PED ped, ICH lineNumber) 
{
    ICH result;

    if (lineNumber >= ped->cLines)
    {
        return 0;
    }

    if (lineNumber == ped->cLines - 1) 
    {
        //
        // Since we can't have a CRLF on the last line
        //
        return (ped->cch - ped->chLines[ped->cLines - 1]);
    } 
    else 
    {
        result = ped->chLines[lineNumber + 1] - ped->chLines[lineNumber];
        TraceMsg(TF_STANDARD, "Edit: MLLine result=%d", result);

        //
        // Now check for CRLF or CRCRLF at end of line
        //
        if (result > 1) 
        {
            if (ped->fAnsi) 
            {
                LPSTR pText;

                pText = Edit_Lock(ped) + ped->chLines[lineNumber + 1] - 2;
                if (*(WORD UNALIGNED *)pText == 0x0A0D) 
                {
                    result -= 2;
                    if (result && *(--pText) == 0x0D)
                    {
                        //
                        // In case there was a CRCRLF
                        //
                        result--;
                    }
                }
            } 
            else 
            {
                LPWSTR pwText;

                pwText = (LPWSTR)Edit_Lock(ped) + (ped->chLines[lineNumber + 1] - 2);
                if (*(DWORD UNALIGNED *)pwText == 0x000A000D) 
                {
                    result = result - 2;
                    if (result && *(--pwText) == 0x0D)
                    {
                        //
                        // In case there was a CRCRLF
                        //
                        result--;
                    }
                }

            }

            Edit_Unlock(ped);
        }
    }

    return result;
}


//---------------------------------------------------------------------------//
//
// EditML_IchToLine AorW
//
// Returns the line number (starting from 0) which contains the given
// character index. If ich is -1, return the line the first char in the
// selection is on (the caret if no selection)
//
INT EditML_IchToLine(PED ped, ICH ich)
{
    int iLo, iHi, iLine;

    iLo = 0;
    iHi = ped->cLines;

    if (ich == (ICH)-1)
    {
        ich = ped->ichMinSel;
    }

    while (iLo < iHi - 1) 
    {
        iLine = max((iHi - iLo)/2, 1) + iLo;

        if (ped->chLines[iLine] > ich) 
        {
            iHi = iLine;
        } 
        else 
        {
            iLo = iLine;
        }
    }

    return iLo;
}


//---------------------------------------------------------------------------//
//
// EditML_IchToYPos
//
// Given an ich, return its y coordinate with respect to the top line
// displayed in the window. If prevLine is TRUE and if the ich is at the
// beginning of the line, return the y coordinate of the
// previous line (if it is not a CRLF).
// 
// Added for the LPK (3Dec96) - with an LPK installed, calculating X position is
// a far more processor intensive job. Where only the Y position is required
// this routine should be called instead of EditML_IchToXYPos.
// 
// Called only when LPK installed.
//
INT EditML_IchToYPos( PED  ped, ICH  ich, BOOL prevLine)
{
    int  iline;
    int  yPosition;
    PSTR pText;

    //
    // Determine what line the character is on
    //
    iline = EditML_IchToLine(ped, ich);

    //
    // Calc. the yPosition now. Note that this may change by the height of one
    // char if the prevLine flag is set and the ICH is at the beginning of a line.
    //
    yPosition = (iline - ped->ichScreenStart) * ped->lineHeight + ped->rcFmt.top;

    pText = Edit_Lock(ped);
    if (prevLine && iline && (ich == ped->chLines[iline]) &&
            (!AWCOMPARECHAR(ped, pText + (ich - 2) * ped->cbChar, 0x0D) ||
             !AWCOMPARECHAR(ped, pText + (ich - 1) * ped->cbChar, 0x0A))) 
    {
        //
        // First char in the line. We want Y position of the previous
        // line if we aren't at the 0th line.
        //
        iline--;

        yPosition = yPosition - ped->lineHeight;
    }

    Edit_Unlock(ped);

    return yPosition;
}


//---------------------------------------------------------------------------//
//
// EditML_IchToXYPos
//
// Given an ich, return its x,y coordinates with respect to the top
// left character displayed in the window. Returns the coordinates of the top
// left position of the char. If prevLine is TRUE then if the ich is at the
// beginning of the line, we will return the coordinates to the right of the
// last char on the previous line (if it is not a CRLF).
//
VOID EditML_IchToXYPos(PED ped, HDC hdc, ICH ich, BOOL prevLine, LPPOINT ppt)
{
    int iline;
    ICH cch;
    int xPosition, yPosition;
    int xOffset;

    //
    // For horizontal scroll displacement on left justified text and
    // for indent on centered or right justified text
    //
    PSTR pText, pTextStart, pLineStart;

    //
    // Determine what line the character is on
    //
    iline = EditML_IchToLine(ped, ich);

    //
    // Calc. the yPosition now. Note that this may change by the height of one
    // char if the prevLine flag is set and the ICH is at the beginning of a line.
    //
    yPosition = (iline - ped->ichScreenStart) * ped->lineHeight + ped->rcFmt.top;

    //
    // Now determine the xPosition of the character
    //
    pTextStart = Edit_Lock(ped);

    if (prevLine && iline && (ich == ped->chLines[iline]) &&
            (!AWCOMPARECHAR(ped, pTextStart + (ich - 2) * ped->cbChar, 0x0D) ||
            !AWCOMPARECHAR(ped, pTextStart + (ich - 1) * ped->cbChar, 0x0A))) 
    {
        //
        // First char in the line. We want text extent upto end of the previous
        // line if we aren't at the 0th line.
        //
        iline--;

        yPosition = yPosition - ped->lineHeight;
        pLineStart = pTextStart + ped->chLines[iline] * ped->cbChar;

        //
        // Note that we are taking the position in front of any CRLFs in the
        // text.
        //
        cch = EditML_Line(ped, iline);

    } 
    else 
    {
        pLineStart = pTextStart + ped->chLines[iline] * ped->cbChar;
        pText = pTextStart + ich * ped->cbChar;

        //
        // Strip off CRLF or CRCRLF. Note that we may be pointing to a CR but in
        // which case we just want to strip off a single CR or 2 CRs.
        //

        //
        // We want pText to point to the first CR at the end of the line if
        // there is one. Thus, we will get an xPosition to the right of the last
        // visible char on the line otherwise we will be to the left of
        // character ich.
        //

        //
        // Check if we at the end of text
        //
        if (ich < ped->cch) 
        {
            if (ped->fAnsi) 
            {
                if (ich && *(WORD UNALIGNED *)(pText - 1) == 0x0A0D) 
                {
                    pText--;
                    if (ich > 2 && *(pText - 1) == 0x0D)
                    {
                        pText--;
                    }
                }
            } 
            else 
            {
                LPWSTR pwText = (LPWSTR)pText;

                if (ich && *(DWORD UNALIGNED *)(pwText - 1) == 0x000A000D) 
                {
                    pwText--;
                    if (ich > 2 && *(pwText - 1) == 0x0D)
                    {
                        pwText--;
                    }
                }

                pText = (LPSTR)pwText;
            }
        }

        if (pText < pLineStart)
        {
            pText = pLineStart;
        }

        cch = (ICH)(pText - pLineStart)/ped->cbChar;
    }

    //
    // Find out how many pixels we indent the line for funny formats
    //
    if (ped->pLpkEditCallout) 
    {
        //
        // Must find position at start of character offset cch from start of line.
        // This depends on the layout and the reading order
        //
        xPosition = ped->pLpkEditCallout->EditIchToXY(
                          (PED0)ped, hdc, pLineStart, EditML_Line(ped, iline), cch);
    } 
    else 
    {
        if (ped->format != ES_LEFT) 
        {
            xOffset = EditML_CalcXOffset(ped, hdc, iline);
        } 
        else 
        {
            xOffset = -(int)ped->xOffset;
        }

        xPosition = ped->rcFmt.left + xOffset +
                EditML_GetLineWidth(hdc, pLineStart, cch, ped);
    }

    Edit_Unlock(ped);

    ppt->x = xPosition;
    ppt->y = yPosition;

    return;
}


//---------------------------------------------------------------------------//
//
// EditML_MouseToIch AorW
//
// Returns the closest cch to where the mouse point is.  Also optionally
// returns lineindex in pline (So that we can tell if we are at the beginning
// of the line or end of the previous line.)
//
ICH EditML_MouseToIch(PED ped, HDC hdc, LPPOINT mousePt, LPICH pline)
{
    int xOffset;
    LPSTR pLineStart;
    int height = mousePt->y;
    int line; //WASINT
    int width = mousePt->x;
    ICH cch;
    ICH cLineLength;
    ICH cLineLengthNew;
    ICH cLineLengthHigh;
    ICH cLineLengthLow;
    ICH cLineLengthTemp;
    int textWidth;
    int iCurWidth;
    int lastHighWidth, lastLowWidth;

    //
    // First determine which line the mouse is pointing to.
    //
    line = ped->ichScreenStart;
    if (height <= ped->rcFmt.top) 
    {
        //
        // Either return 0 (the very first line, or one line before the top line
        // on the screen. Note that these are signed mins and maxes since we
        // don't expect (or allow) more than 32K lines.
        //
        line = max(0, line-1);
    } 
    else if (height >= ped->rcFmt.bottom) 
    {
        //
        // Are we below the last line displayed
        //
        line = min(line+(int)ped->ichLinesOnScreen, (int)(ped->cLines-1));
    } 
    else 
    {
        //
        // We are somewhere on a line visible on screen
        //
        line = min(line + (int)((height - ped->rcFmt.top) / ped->lineHeight),
                (int)(ped->cLines - 1));
    }

    //
    // Now determine what horizontal character the mouse is pointing to.
    //
    pLineStart = Edit_Lock(ped) + ped->chLines[line] * ped->cbChar;
    cLineLength = EditML_Line(ped, line); // Length is sans CRLF or CRCRLF
    TraceMsg(TF_STANDARD, "Edit: EditML_Line(ped=%x, line=%d) returned %d", ped, line, cLineLength);
    UserAssert((int)cLineLength >= 0);

    //
    // If the language pack is loaded, visual and logical character order
    // may differ.
    //
    if (ped->pLpkEditCallout) 
    {
        //
        // Use the language pack to find the character nearest the cursor.
        //
        cch = ped->chLines[line] + ped->pLpkEditCallout->EditMouseToIch
            ((PED0)ped, hdc, pLineStart, cLineLength, width);
    } 
    else 
    {
        //
        // xOffset will be a negative value for center and right justified lines.
        // ie. We will just displace the lines left by the amount of indent for
        // right and center justification. Note that ped->xOffset will be 0 for
        // these lines since we don't support horizontal scrolling with them.
        //
        if (ped->format != ES_LEFT) 
        {
            xOffset = EditML_CalcXOffset(ped, hdc, line);
        } 
        else 
        {
            //
            // So that we handle a horizontally scrolled window for left justified
            // text.
            //
            xOffset = 0;
        }

        width = width - xOffset;

        //
        // The code below is tricky... I depend on the fact that ped->xOffset is 0
        // for right and center justified lines
        //

        //
        // Now find out how many chars fit in the given width
        //
        if (width >= ped->rcFmt.right) 
        {
            //
            // Return 1+last char in line or one plus the last char visible
            //
            cch = Edit_CchInWidth(ped, hdc, pLineStart, cLineLength,
                    ped->rcFmt.right - ped->rcFmt.left + ped->xOffset, TRUE);

            //
            // Consider DBCS in case of width >= ped->rcFmt.right
            //
            // Since Edit_CchInWidth and EditML_LineLength takes care of DBCS, we only need to
            // worry about if the last character is a double byte character or not.
            //
            // cch = ped->chLines[line] + min( Edit_NextIch(ped, pLineStart, cch), cLineLength);
            //
            // we need to adjust the position. LiZ -- 5/5/93
            //
            if (ped->fAnsi && ped->fDBCS) 
            {
                ICH cch2 = min(cch+1,cLineLength);
                if (Edit_AdjustIch(ped, pLineStart, cch2) != cch2) 
                {
                    //
                    // Displayed character on the right edge is DBCS
                    //
                    cch = min(cch+2,cLineLength);
                } 
                else 
                {
                    cch = cch2;
                }

                cch += ped->chLines[line];
            } 
            else 
            {
                cch = ped->chLines[line] + min(cch + 1, cLineLength);
            }
        } 
        else if (width <= ped->rcFmt.left + ped->aveCharWidth / 2) 
        {
            //
            // Return first char in line or one minus first char visible. Note that
            // ped->xOffset is 0 for right and centered text so we will just return
            // the first char in the string for them. (Allow a avecharwidth/2
            // positioning border so that the user can be a little off...
            //
            cch = Edit_CchInWidth(ped, hdc, pLineStart, cLineLength, ped->xOffset, TRUE);
            if (cch)
            {
                cch--;
            }

            cch = Edit_AdjustIch( ped, pLineStart, cch );
            cch += ped->chLines[line];
        } 
        else 
        {
            if (cLineLength == 0) 
            {
                cch = ped->chLines[line];
                goto edUnlock;
            }

            iCurWidth = width + ped->xOffset - ped->rcFmt.left;

            //
            // If the user clicked past the end of the text, return the last character
            //
            lastHighWidth = EditML_GetLineWidth(hdc, pLineStart, cLineLength, ped);
            if (lastHighWidth <= iCurWidth) 
            {
                cLineLengthNew = cLineLength;
                goto edAdjust;
            }

            //
            // Now the mouse is somewhere on the visible portion of the text
            // remember cch contains the length of the line.
            //
            cLineLengthLow = 0;
            cLineLengthHigh = cLineLength + 1;
            lastLowWidth = 0;

            while (cLineLengthLow < cLineLengthHigh - 1) 
            {
                cLineLengthNew = (cLineLengthHigh + cLineLengthLow) / 2;

                if (ped->fAnsi && ped->fDBCS) 
                {
                    //
                    // EditML_GetLineWidth returns meaningless value for truncated DBCS.
                    //
                    cLineLengthTemp = Edit_AdjustIch(ped, pLineStart, cLineLengthNew);
                    textWidth = EditML_GetLineWidth(hdc, pLineStart, cLineLengthTemp, ped);

                } 
                else 
                {
                    textWidth = EditML_GetLineWidth(hdc, pLineStart, cLineLengthNew, ped);
                }

                if (textWidth > iCurWidth) 
                {
                    cLineLengthHigh = cLineLengthNew;
                    lastHighWidth = textWidth;
                } 
                else 
                {
                    cLineLengthLow = cLineLengthNew;
                    lastLowWidth = textWidth;
                }
            }

            //
            // When the while ends, you can't know the exact desired position.
            // Try to see if the mouse pointer was on the farest half
            // of the char we got and if so, adjust cch.
            //
            if (cLineLengthLow == cLineLengthNew) 
            {
                //
                // Need to compare with lastHighWidth
                //
                if ((lastHighWidth - iCurWidth) < (iCurWidth - textWidth)) 
                {
                    cLineLengthNew++;
                }
            } 
            else 
            {
                //
                // Need to compare with lastLowHigh
                //
                if ((iCurWidth - lastLowWidth) < (textWidth - iCurWidth)) 
                {
                    cLineLengthNew--;
                }
            }
edAdjust:
            cLineLength = Edit_AdjustIch( ped, pLineStart, cLineLengthNew );

            cch = ped->chLines[line] + cLineLength;
        }
    }

edUnlock:
    Edit_Unlock(ped);

    if (pline) 
    {
        *pline = line;
    }

    return cch;
}


//---------------------------------------------------------------------------//
//
// EditML_ChangeSelection AorW
// 
// Changes the current selection to have the specified starting and
// ending values. Properly highlights the new selection and unhighlights
// anything deselected. If NewMinSel and NewMaxSel are out of order, we swap
// them. Doesn't update the caret position.
//
VOID EditML_ChangeSelection(PED ped, HDC hdc, ICH ichNewMinSel, ICH ichNewMaxSel)
{

    ICH temp;
    ICH ichOldMinSel, ichOldMaxSel;

    if (ichNewMinSel > ichNewMaxSel) 
    {
        temp = ichNewMinSel;
        ichNewMinSel = ichNewMaxSel;
        ichNewMaxSel = temp;
    }

    ichNewMinSel = min(ichNewMinSel, ped->cch);
    ichNewMaxSel = min(ichNewMaxSel, ped->cch);

    //
    // Save the current selection
    //
    ichOldMinSel = ped->ichMinSel;
    ichOldMaxSel = ped->ichMaxSel;

    //
    // Set new selection
    //
    ped->ichMinSel = ichNewMinSel;
    ped->ichMaxSel = ichNewMaxSel;

    //
    // This finds the XOR of the old and new selection regions and redraws it.
    // There is nothing to repaint if we aren't visible or our selection
    // is hidden.
    //
    if (IsWindowVisible(ped->hwnd) && (ped->fFocus || ped->fNoHideSel)) 
    {

        SELBLOCK Blk[2];
        int i;

        if (ped->fFocus) 
        {
            HideCaret(ped->hwnd);
        }

        Blk[0].StPos = ichOldMinSel;
        Blk[0].EndPos = ichOldMaxSel;
        Blk[1].StPos = ped->ichMinSel;
        Blk[1].EndPos = ped->ichMaxSel;

        if (Edit_CalcChangeSelection(ped, ichOldMinSel, ichOldMaxSel, (LPSELBLOCK)&Blk[0], (LPSELBLOCK)&Blk[1])) 
        {
            //
            // Paint both Blk[0] and Blk[1], if they exist
            //
            for (i = 0; i < 2; i++) 
            {
                if (Blk[i].StPos != 0xFFFFFFFF)
                    EditML_DrawText(ped, hdc, Blk[i].StPos, Blk[i].EndPos, TRUE);
            }
        }

        //
        // Update caret.
        //
        EditML_SetCaretPosition(ped, hdc);

        if (ped->fFocus) 
        {
            ShowCaret(ped->hwnd);
        }
    }
}


//---------------------------------------------------------------------------//
//
// EditML_UpdateiCaretLine AorW
// 
// This updates the ped->iCaretLine field from the ped->ichCaret;
// Also, when the caret gets to the beginning of next line, pop it up to
// the end of current line when inserting text;
//
VOID EditML_UpdateiCaretLine(PED ped)
{
    PSTR pText;

    ped->iCaretLine = EditML_IchToLine(ped, ped->ichCaret);

    //
    // If caret gets to beginning of next line, pop it up to end of current line
    // when inserting text.
    //
    pText = Edit_Lock(ped) +
            (ped->ichCaret - 1) * ped->cbChar;
    if (ped->iCaretLine && ped->chLines[ped->iCaretLine] == ped->ichCaret &&
            (!AWCOMPARECHAR(ped, pText - ped->cbChar, 0x0D) ||
            !AWCOMPARECHAR(ped, pText, 0x0A)))
    {
        ped->iCaretLine--;
    }

    Edit_Unlock(ped);
}


//---------------------------------------------------------------------------//
//
// EditML_InsertText AorW
//
// Adds up to cchInsert characters from lpText to the ped starting at
// ichCaret. If the ped only allows a maximum number of characters, then we
// will only add that many characters to the ped. The number of characters
// actually added is return ed (could be 0). If we can't allocate the required
// space, we notify the parent with EN_ERRSPACE and no characters are added.
// do some stuff faster since we will be getting only one or two chars of input.
//
ICH EditML_InsertText(PED ped, LPSTR lpText, ICH cchInsert, BOOL fUserTyping)
{
    HDC hdc;
    ICH validCch = cchInsert;
    ICH oldCaret = ped->ichCaret;
    int oldCaretLine = ped->iCaretLine;
    BOOL fCRLF = FALSE;
    LONG ll, hl;
    POINT xyPosInitial;
    POINT xyPosFinal;
    HWND hwndSave = ped->hwnd;
    UNDO undo;
    ICH validCchTemp;

    xyPosInitial.x=0;
    xyPosInitial.y=0;
    xyPosFinal.x=0;
    xyPosFinal.y=0;

    if (validCch == 0)
    {
        return 0;
    }

    if (ped->cchTextMax <= ped->cch) 
    {
        //
        // When the max chars is reached already, notify parent
        // Fix for Bug #4183 -- 02/06/91 -- SANKAR --
        //
        Edit_NotifyParent(ped,EN_MAXTEXT);
        return 0;
    }

    //
    // Limit the amount of text we add
    //
    validCch = min(validCch, ped->cchTextMax - ped->cch);

    //
    // Make sure we don't split a CRLF in half
    //
    if (validCch) 
    {
        if (ped->fAnsi) 
        {
            if (*(WORD UNALIGNED *)(lpText + validCch - 1) == 0x0A0D)
            {
                validCch--;
            }
        } 
        else 
        {
            if (*(DWORD UNALIGNED *)(lpText + (validCch - 1) * ped->cbChar) == 0x000A000D)
            {
                validCch--;
            }
        }
    }

    if (!validCch) 
    {
        //
        // When the max chars is reached already, notify parent
        // Fix for Bug #4183 -- 02/06/91 -- SANKAR --
        //
        Edit_NotifyParent(ped,EN_MAXTEXT);
        return 0;
    }

    if (validCch == 2) 
    {
        if (ped->fAnsi) 
        {
            if (*(WORD UNALIGNED *)lpText == 0x0A0D)
            {
                fCRLF = TRUE;
            }
        } 
        else 
        {
            if (*(DWORD UNALIGNED *)lpText == 0x000A000D)
            {
                fCRLF = TRUE;
            }
        }
    }

    //
    // Save current undo state always, but clear it out only if !AutoVScroll
    //
    Edit_SaveUndo(Pundo(ped), (PUNDO)&undo, !ped->fAutoVScroll);

    hdc = Edit_GetDC(ped, FALSE);

    //
    // We only need the y position. Since with an LPK loaded
    // calculating the x position is an intensive job, just
    // call EditML_IchToYPos.
    //
    if (ped->cch)
    {
        if (ped->pLpkEditCallout)
        {
            xyPosInitial.y = EditML_IchToYPos(ped, ped->cch-1, FALSE);
        }
        else
        {
            EditML_IchToXYPos(ped, hdc, ped->cch - 1, FALSE, &xyPosInitial);
        }
    }

    //
    // Insert the text
    //
    validCchTemp = validCch;    // may not be needed, but just for precautions..
    if (!Edit_InsertText(ped, lpText, &validCchTemp)) 
    {
        //
        // Restore previous undo buffer if it was cleared
        //
        if (!ped->fAutoVScroll)
        {
            Edit_SaveUndo((PUNDO)&undo, Pundo(ped), FALSE);
        }

        Edit_ReleaseDC(ped, hdc, FALSE);
        Edit_NotifyParent(ped, EN_ERRSPACE);

        return 0;
    }

#if DBG
    if (validCch != validCchTemp) 
    {
        //
        // All characters in lpText has not been inserted to ped.
        // This could happen when cch is close to cchMax.
        // Better revisit this after NT5 ships.
        //
        TraceMsg(TF_STANDARD, "Edit: EditML_InsertText: validCch is changed (%x -> %x) in Edit_InsertText.",
            validCch, validCchTemp);
    }
#endif

    //
    // Note that ped->ichCaret is updated by Edit_InsertText
    //
    EditML_BuildchLines(ped, (ICH)oldCaretLine, (int)validCch, fCRLF?(BOOL)FALSE:fUserTyping, &ll, &hl);

    if (ped->cch)
    {
        //
        // We only need the y position. Since with an LPK loaded
        // calculating the x position is an intensive job, just
        // call EditML_IchToYPos.
        if (ped->pLpkEditCallout)
        {
            xyPosFinal.y = EditML_IchToYPos(ped, ped->cch-1, FALSE);
        }
        else
        {
            EditML_IchToXYPos(ped, hdc, ped->cch - 1, FALSE,&xyPosFinal);
        }
    }

    if (xyPosFinal.y < xyPosInitial.y && ((ICH)ped->ichScreenStart) + ped->ichLinesOnScreen >= ped->cLines - 1) 
    {
        RECT rc;

        CopyRect((LPRECT)&rc, (LPRECT)&ped->rcFmt);
        rc.top = xyPosFinal.y + ped->lineHeight;
        if (ped->pLpkEditCallout) 
        {
            int xFarOffset = ped->xOffset + ped->rcFmt.right - ped->rcFmt.left;

            //
            // Include left or right margins in display unless clipped
            // by horizontal scrolling.
            //
            if (ped->wLeftMargin) 
            {
                if (!(ped->format == ES_LEFT     // Only ES_LEFT (Nearside alignment) can get clipped
                      && (   (!ped->fRtoLReading && ped->xOffset > 0)  // LTR and first char not fully in view
                          || ( ped->fRtoLReading && xFarOffset < ped->maxPixelWidth)))) //RTL and last char not fully in view
                { 
                    rc.left  -= ped->wLeftMargin;
                }
            }

            //
            // Process right margin
            //
            if (ped->wRightMargin) 
            {
                if (!(ped->format == ES_LEFT     // Only ES_LEFT (Nearside alignment) can get clipped
                      && (( ped->fRtoLReading && ped->xOffset > 0)  // RTL and first char not fully in view
                          || (!ped->fRtoLReading && xFarOffset < ped->maxPixelWidth)))) // LTR and last char not fully in view
                { 
                    rc.right += ped->wRightMargin;
                }
            }
        }

        InvalidateRect(ped->hwnd, (LPRECT)&rc, TRUE);
    }

    if (!ped->fAutoVScroll) 
    {
        if (ped->ichLinesOnScreen < ped->cLines) 
        {
            EditML_Undo(ped);
            Edit_EmptyUndo(Pundo(ped));

            Edit_SaveUndo(&undo, Pundo(ped), FALSE);

            MessageBeep(0);
            Edit_ReleaseDC(ped, hdc, FALSE);

            //
            // When the max lines is reached already, notify parent
            // Fix for Bug #7586 -- 10/14/91 -- SANKAR --
            //
            Edit_NotifyParent(ped,EN_MAXTEXT);

            return 0;
        } 
        else 
        {
            Edit_EmptyUndo(&undo);
        }
    }

    if (fUserTyping && ped->fWrap) 
    {
        //
        // To avoid oldCaret points intermediate of DBCS character,
        // adjust oldCaret position if necessary.
        //
        // !!!CR If EditML_BuildchLines() returns reasonable value ( and I think
        //       it does), we don't probably need this. Check this out later.
        //
        if (ped->fDBCS && ped->fAnsi) 
        {
            oldCaret = Edit_AdjustIch(ped,
                                   Edit_Lock(ped),
                                   min((ICH)LOWORD(ll),oldCaret));
        } 
        else 
        {
            oldCaret = min((ICH)LOWORD(ll), oldCaret);
        }
    }

    //
    // Update ped->iCaretLine properly.
    //
    EditML_UpdateiCaretLine(ped);

    Edit_NotifyParent(ped, EN_UPDATE);

    //
    // Make sure window still exists.
    //
    if (!IsWindow(hwndSave))
    {
        return 0;
    }

    if (IsWindowVisible(ped->hwnd)) 
    {
        //
        // If the current font has negative A widths, we may have to start
        // drawing a few characters before the oldCaret position.
        //
        if (ped->wMaxNegAcharPos) 
        {
            int iLine = EditML_IchToLine(ped, oldCaret);
            oldCaret = max( ((int)(oldCaret - ped->wMaxNegAcharPos)),
                          ((int)(ped->chLines[iLine])));
        }

        //
        // Redraw to end of screen/text if CRLF or large insert
        //
        if (fCRLF || !fUserTyping) 
        {
            //
            // Redraw to end of screen/text if crlf or large insert.
            //
            EditML_DrawText(ped, hdc, (fUserTyping ? oldCaret : 0), ped->cch, FALSE);
        } 
        else
        {
            EditML_DrawText(ped, hdc, oldCaret, max(ped->ichCaret, (ICH)hl), FALSE);
        }
    }

    Edit_ReleaseDC(ped, hdc, FALSE);

    //
    // Make sure we can see the cursor
    //
    EditML_EnsureCaretVisible(ped);

    ped->fDirty = TRUE;

    Edit_NotifyParent(ped, EN_CHANGE);

    if (validCch < cchInsert)
    {
        Edit_NotifyParent(ped, EN_MAXTEXT);
    }

    if (validCch) 
    {
        NotifyWinEvent(EVENT_OBJECT_VALUECHANGE, ped->hwnd, OBJID_CLIENT, INDEXID_CONTAINER);
    }

    //
    // Make sure the window still exists.
    //
    return IsWindow(hwndSave) ? validCch : 0;
}


//---------------------------------------------------------------------------//
//
// EditML_ReplaceSel
// 
// Replaces currently selected text with the passed in text, WITH UNDO
// CAPABILITIES.
//
VOID EditML_ReplaceSel(PED ped, LPSTR lpText)
{
    ICH  cchText;

    //
    // Delete text, which will put it into the clean undo buffer.
    //
    Edit_EmptyUndo(Pundo(ped));
    EditML_DeleteText(ped);

    //
    // B#3356
    // Some apps do "clear" by selecting all of the text, then replacing
    // it with "", in which case EditML_InsertText() will return 0.  But that
    // doesn't mean failure...
    //
    if ( ped->fAnsi )
    {
        cchText = strlen(lpText);
    }
    else
    {
        cchText = wcslen((LPWSTR)lpText);
    }

    if (cchText) 
    {
        BOOL fFailed;
        UNDO undo;
        HWND hwndSave;

        //
        // B#1385,1427
        // Save undo buffer, but DO NOT CLEAR IT.  We want to restore it
        // if insertion fails due to OOM.
        //
        Edit_SaveUndo(Pundo(ped), (PUNDO)&undo, FALSE);

        hwndSave = ped->hwnd;
        fFailed = (BOOL) !EditML_InsertText(ped, lpText, cchText, FALSE);
        if (!IsWindow(hwndSave))
        {
            return;
        }

        if (fFailed) 
        {
            //
            // UNDO the previous edit
            //
            Edit_SaveUndo((PUNDO)&undo, Pundo(ped), FALSE);
            EditML_Undo(ped);
        }
    }
}


//---------------------------------------------------------------------------//
// 
// EditML_DeleteText AorW
//
// Deletes the characters between ichMin and ichMax. Returns the
// number of characters we deleted.
//
ICH EditML_DeleteText(PED ped)
{
    ICH minSel = ped->ichMinSel;
    ICH maxSel = ped->ichMaxSel;
    ICH cchDelete;
    HDC hdc;
    int minSelLine;
    int maxSelLine;
    POINT xyPos;
    RECT rc;
    BOOL fFastDelete = FALSE;
    LONG hl;
    INT  cchcount = 0;

    //
    // Get what line the min selection is on so that we can start rebuilding the
    // text from there if we delete anything.
    //
    minSelLine = EditML_IchToLine(ped, minSel);
    maxSelLine = EditML_IchToLine(ped, maxSel);

    //
    // Calculate fFastDelete and cchcount
    //
    if (ped->fAnsi && ped->fDBCS) 
    {
        if ((ped->fAutoVScroll) &&
            (minSelLine == maxSelLine) &&
            (ped->chLines[minSelLine] != minSel)  &&
            (Edit_NextIch(ped,NULL,minSel) == maxSel)) 
        {

                fFastDelete = TRUE;
                cchcount = ((maxSel - minSel) == 1) ? 0 : -1;
        }
    } 
    else if (((maxSel - minSel) == 1) && (minSelLine == maxSelLine) && (ped->chLines[minSelLine] != minSel)) 
    {
        fFastDelete = ped->fAutoVScroll ? TRUE : FALSE;
    }

    cchDelete = Edit_DeleteText(ped);
    if (!cchDelete)
    {
        return 0;
    }

    //
    // Start building lines at minsel line since caretline may be at the max sel
    // point.
    //
    if (fFastDelete) 
    {
        //
        // cchcount is (-1) if it's a double byte character
        //
        EditML_ShiftchLines(ped, minSelLine + 1, -2 + cchcount);
        EditML_BuildchLines(ped, minSelLine, 1, TRUE, NULL, &hl);
    } 
    else 
    {
        EditML_BuildchLines(ped, max(minSelLine-1,0), -(int)cchDelete, FALSE, NULL, NULL);
    }

    EditML_UpdateiCaretLine(ped);

    Edit_NotifyParent(ped, EN_UPDATE);

    if (IsWindowVisible(ped->hwnd)) 
    {
        //
        // Now update the screen to reflect the deletion
        //
        hdc = Edit_GetDC(ped, FALSE);

        //
        // Otherwise just redraw starting at the line we just entered
        //
        minSelLine = max(minSelLine-1,0);
        EditML_DrawText(ped, hdc, ped->chLines[minSelLine], fFastDelete ? hl : ped->cch, FALSE);

        CopyRect(&rc, &ped->rcFmt);
        rc.left  -= ped->wLeftMargin;
        rc.right += ped->wRightMargin;

        if (ped->cch) 
        {
            //
            //  Clear from end of text to end of window.
            //  
            //  We only need the y position. Since with an LPK loaded
            //  calculating the x position is an intensive job, just
            //  call EditML_IchToYPos.
            //
            if (ped->pLpkEditCallout)
            {
                xyPos.y = EditML_IchToYPos(ped, ped->cch, FALSE);
            }
            else
            {
                EditML_IchToXYPos(ped, hdc, ped->cch, FALSE, &xyPos);
            }

            rc.top = xyPos.y + ped->lineHeight;
        }

        InvalidateRect(ped->hwnd, &rc, TRUE);
        Edit_ReleaseDC(ped, hdc, FALSE);

        EditML_EnsureCaretVisible(ped);
    }

    ped->fDirty = TRUE;

    Edit_NotifyParent(ped, EN_CHANGE);

    if (cchDelete)
    {
        NotifyWinEvent(EVENT_OBJECT_VALUECHANGE, ped->hwnd, OBJID_CLIENT, INDEXID_CONTAINER);
    }

    return cchDelete;
}


//---------------------------------------------------------------------------//
//
// EditML_InsertchLine AorW
//
// Inserts the line iline and sets its starting character index to be
// ich. All the other line indices are moved up. Returns TRUE if successful
// else FALSE and notifies the parent that there was no memory.
//
BOOL EditML_InsertchLine(PED ped, ICH iLine, ICH ich, BOOL fUserTyping)
{
    DWORD dwSize;

    if (fUserTyping && iLine < ped->cLines) 
    {
        ped->chLines[iLine] = ich;
        return TRUE;
    }

    dwSize = (ped->cLines + 2) * sizeof(int);

    if (dwSize > UserLocalSize(ped->chLines)) 
    {
        LPICH hResult;

        //
        // Grow the line index buffer
        //
        dwSize += LINEBUMP * sizeof(int);
        hResult = (LPICH)UserLocalReAlloc(ped->chLines, dwSize, 0);

        if (!hResult) 
        {
            Edit_NotifyParent(ped, EN_ERRSPACE);
            return FALSE;
        }
        ped->chLines = hResult;
    }

    //
    // Move indices starting at iLine up
    //
    if (ped->cLines != iLine)
    {
        RtlMoveMemory(&ped->chLines[iLine + 1], &ped->chLines[iLine],
                (ped->cLines - iLine) * sizeof(int));
    }

    ped->cLines++;
    ped->chLines[iLine] = ich;

    return TRUE;
}


//---------------------------------------------------------------------------//
//
// EditML_ShiftchLines AorW
//
// Move the starting index of all lines iLine or greater by delta
// bytes.
//
void EditML_ShiftchLines(PED ped, ICH iLine, int delta)
{
    if (iLine < ped->cLines)
    {
        //
        // Just add delta to the starting point of each line after iLine
        //
        for (; iLine < ped->cLines; iLine++)
        {
            ped->chLines[iLine] += delta;
        }
    }
}


//---------------------------------------------------------------------------//
//
// EditML_BuildchLines AorW
// 
// Rebuilds the start of line array (ped->chLines) starting at line
// number ichLine.
//
void EditML_BuildchLines( PED ped, ICH iLine, int cchDelta, BOOL fUserTyping, PLONG pll, PLONG phl)
{
    PSTR ptext;     // Starting address of the text

    //
    // We keep these ICH's so that we can Unlock ped->hText when we have to grow
    // the chlines array. With large text handles, it becomes a problem if we
    // have a locked block in the way.
    //
    ICH ichLineStart;
    ICH ichLineEnd;
    ICH ichLineEndBeforeCRLF;
    ICH ichCRLF;

    ICH cch;
    HDC hdc;

    BOOL fLineBroken = FALSE;   // Initially, no new line breaks are made
    ICH minCchBreak;
    ICH maxCchBreak;
    BOOL fOnDelimiter;

    if (!ped->cch) 
    {
        ped->maxPixelWidth = 0;
        ped->xOffset = 0;
        ped->ichScreenStart = 0;
        ped->cLines = 1;

        if (pll)
        {
            *pll = 0;
        }

        if (phl)
        {
            *phl = 0;
        }

        goto UpdateScroll;
    }

    if (fUserTyping && cchDelta)
    {
        EditML_ShiftchLines(ped, iLine + 1, cchDelta);
    }

    hdc = Edit_GetDC(ped, TRUE);

    if (!iLine && !cchDelta && !fUserTyping) 
    {
        //
        // Reset maxpixelwidth only if we will be running through the whole
        // text. Better too long than too short.
        //
        ped->maxPixelWidth = 0;

        //
        // Reset number of lines in text since we will be running through all
        // the text anyway...
        //
        ped->cLines = 1;
    }

    //
    // Set min and max line built to be the starting line
    //
    minCchBreak = maxCchBreak = (cchDelta ? ped->chLines[iLine] : 0);

    ptext = Edit_Lock(ped);

    ichCRLF = ichLineStart = ped->chLines[iLine];

    while (ichLineStart < ped->cch) 
    {
        if (ichLineStart >= ichCRLF) 
        {
            ichCRLF = ichLineStart;

            //
            // Move ichCRLF ahead to either the first CR or to the end of text.
            //
            if (ped->fAnsi) 
            {
                while (ichCRLF < ped->cch) 
                {
                    if (*(ptext + ichCRLF) == 0x0D) 
                    {
                        if (*(ptext + ichCRLF + 1) == 0x0A ||
                                *(WORD UNALIGNED *)(ptext + ichCRLF + 1) == 0x0A0D)
                        {
                            break;
                        }
                    }

                    ichCRLF++;
                }
            } 
            else 
            {
                LPWSTR pwtext = (LPWSTR)ptext;

                while (ichCRLF < ped->cch) 
                {
                    if (*(pwtext + ichCRLF) == 0x0D) 
                    {
                        if (*(pwtext + ichCRLF + 1) == 0x0A ||
                                *(DWORD UNALIGNED *)(pwtext + ichCRLF + 1) == 0x000A000D)
                        {
                            break;
                        }
                    }

                    ichCRLF++;
                }
            }
        }

        if (!ped->fWrap) 
        {
            UINT  LineWidth;

            //
            // If we are not word wrapping, line breaks are signified by CRLF.
            //

            //
            // If we cut off the line at MAXLINELENGTH, we should
            // adjust ichLineEnd.
            //
            if ((ichCRLF - ichLineStart) <= MAXLINELENGTH) 
            {
                ichLineEnd = ichCRLF;
            } 
            else 
            {
                ichLineEnd = ichLineStart + MAXLINELENGTH;

                if (ped->fAnsi && ped->fDBCS) 
                {
                    ichLineEnd = Edit_AdjustIch( ped, (PSTR)ptext, ichLineEnd);
                }
            }

            //
            // We will keep track of what the longest line is for the horizontal
            // scroll bar thumb positioning.
            //
            if (ped->pLpkEditCallout) 
            {
                LineWidth = ped->pLpkEditCallout->EditGetLineWidth(
                    (PED0)ped, hdc, ptext + ichLineStart*ped->cbChar,
                    ichLineEnd - ichLineStart);
            } 
            else 
            {
                LineWidth = EditML_GetLineWidth(hdc, ptext + ichLineStart * ped->cbChar,
                                            ichLineEnd - ichLineStart,
                                            ped);
            }

            ped->maxPixelWidth = max(ped->maxPixelWidth,(int)LineWidth);

        } 
        else 
        {
            //
            // Check if the width of the edit control is non-zero;
            // a part of the fix for Bug #7402 -- SANKAR -- 01/21/91 --
            //
            if(ped->rcFmt.right > ped->rcFmt.left) 
            {
                //
                // Find the end of the line based solely on text extents
                //
                if (ped->pLpkEditCallout) 
                {
                    ichLineEnd = ichLineStart +
                        ped->pLpkEditCallout->EditCchInWidth(
                            (PED0)ped, hdc, ptext + ped->cbChar*ichLineStart,
                            ichCRLF - ichLineStart,
                            ped->rcFmt.right - ped->rcFmt.left);
                } 
                else 
                {
                    if (ped->fAnsi) 
                    {
                        ichLineEnd = ichLineStart +
                                 Edit_CchInWidth(ped, hdc,
                                              ptext + ichLineStart,
                                              ichCRLF - ichLineStart,
                                              ped->rcFmt.right - ped->rcFmt.left,
                                              TRUE);
                    } 
                    else 
                    {
                        ichLineEnd = ichLineStart +
                                 Edit_CchInWidth(ped, hdc,
                                              (LPSTR)((LPWSTR)ptext + ichLineStart),
                                              ichCRLF - ichLineStart,
                                              ped->rcFmt.right - ped->rcFmt.left,
                                              TRUE);
                    }
                }
            } 
            else 
            {
                ichLineEnd = ichLineStart;
            }

            if (ichLineEnd == ichLineStart && ichCRLF - ichLineStart) 
            {
                //
                // Maintain a minimum of one char per line
                // Since it might be a double byte char, so calling Edit_NextIch.
                //
                ichLineEnd = Edit_NextIch(ped, NULL, ichLineEnd);
            }

            //
            // Now starting from ichLineEnd, if we are not at a hard line break,
            // then if we are not at a space AND the char before us is
            // not a space,(OR if we are at a CR) we will look word left for the
            // start of the word to break at.
            // This change was done for TWO reasons:
            // 1. If we are on a delimiter, no need to look word left to break at.
            // 2. If the previous char is a delimter, we can break at current char.
            // Change done by -- SANKAR --01/31/91--
            //
            if (ichLineEnd != ichCRLF) 
            {
                if(ped->lpfnNextWord) 
                {
                     fOnDelimiter = (CALLWORDBREAKPROC(*ped->lpfnNextWord, ptext,
                            ichLineEnd, ped->cch, WB_ISDELIMITER) ||
                            CALLWORDBREAKPROC(*ped->lpfnNextWord, ptext, ichLineEnd - 1,
                            ped->cch, WB_ISDELIMITER));

                    //
                    // This change was done for FOUR reasons:
                    //
                    // 1. If we are on a delimiter, no need to look word left to break at.
                    // 2. If we are on a double byte character, we can break at current char.
                    // 3. If the previous char is a delimter, we can break at current char.
                    // 4. If the previous char is a double byte character, we can break at current char.
                    //
                } 
                else if (ped->fAnsi) 
                {
                    fOnDelimiter = (ISDELIMETERA(*(ptext + ichLineEnd)) ||
                                    Edit_IsDBCSLeadByte(ped, *(ptext + ichLineEnd)));

                    if (!fOnDelimiter) 
                    {
                        PSTR pPrev = Edit_AnsiPrev(ped,ptext,ptext+ichLineEnd);

                        fOnDelimiter = ISDELIMETERA(*pPrev) ||
                                       Edit_IsDBCSLeadByte(ped,*pPrev);
                    }
                } 
                else 
                { 
                    fOnDelimiter = (ISDELIMETERW(*((LPWSTR)ptext + ichLineEnd))     ||
                                    Edit_IsFullWidth(CP_ACP,*((LPWSTR)ptext + ichLineEnd))      ||
                                    ISDELIMETERW(*((LPWSTR)ptext + ichLineEnd - 1)) ||
                                    Edit_IsFullWidth(CP_ACP,*((LPWSTR)ptext + ichLineEnd - 1)));
                }

                if (!fOnDelimiter ||
                    (ped->fAnsi && *(ptext + ichLineEnd) == 0x0D) ||
                    (!ped->fAnsi && *((LPWSTR)ptext + ichLineEnd) == 0x0D)) 
                {
                    if (ped->lpfnNextWord != NULL) 
                    {
                        cch = CALLWORDBREAKPROC(*ped->lpfnNextWord, (LPSTR)ptext, ichLineEnd,
                                ped->cch, WB_LEFT);
                    } 
                    else 
                    {
                        ped->fCalcLines = TRUE;
                        Edit_Word(ped, ichLineEnd, TRUE, &cch, NULL);
                        ped->fCalcLines = FALSE;
                    }

                    if (cch > ichLineStart) 
                    {
                        ichLineEnd = cch;
                    }

                    //
                    // Now, if the above test fails, it means the word left goes
                    // back before the start of the line ie. a word is longer
                    // than a line on the screen. So, we just fit as much of
                    // the word on the line as possible. Thus, we use the
                    // pLineEnd we calculated solely on width at the beginning
                    // of this else block...
                    //
                }
            }
        }
#if 0
        if (!ISDELIMETERAW((*(ptext + (ichLineEnd - 1)*ped->cbChar))) && ISDELIMETERAW((*(ptext + ichLineEnd*ped->cbChar)))) #ERROR

            if ((*(ptext + ichLineEnd - 1) != ' ' &&
                        *(ptext + ichLineEnd - 1) != VK_TAB) &&
                        (*(ptext + ichLineEnd) == ' ' ||
                        *(ptext + ichLineEnd) == VK_TAB))
#endif
        if (AWCOMPARECHAR(ped,ptext + ichLineEnd * ped->cbChar, ' ') ||
                AWCOMPARECHAR(ped,ptext + ichLineEnd * ped->cbChar, VK_TAB)) 
        {
            //
            // Swallow the space at the end of a line.
            //
            if (ichLineEnd < ped->cch) 
            {
                ichLineEnd++;
            }
        }

        //
        // Skip over crlf or crcrlf if it exists. Thus, ichLineEnd is the first
        // character in the next line.
        //
        ichLineEndBeforeCRLF = ichLineEnd;

        if (ped->fAnsi) 
        {
            if (ichLineEnd < ped->cch && *(ptext + ichLineEnd) == 0x0D)
            {
                ichLineEnd += 2;
            }

            //
            // Skip over CRCRLF
            //
            if (ichLineEnd < ped->cch && *(ptext + ichLineEnd) == 0x0A)
            {
                ichLineEnd++;
            }
        } 
        else 
        {
            if (ichLineEnd < ped->cch && *(((LPWSTR)ptext) + ichLineEnd) == 0x0D)
            {
                ichLineEnd += 2;
            }

            //
            // Skip over CRCRLF
            //
            if (ichLineEnd < ped->cch && *(((LPWSTR)ptext) + ichLineEnd) == 0x0A) 
            {
                ichLineEnd++;
                TraceMsg(TF_STANDARD, "Edit: Skip over CRCRLF");
            }
        }
#if DBG
        if (ichLineEnd > ped->cch)
        {
            TraceMsg(TF_STANDARD, "Edit: ichLineEnd (%d)> ped->cch (%d)", ichLineEnd, ped->cch);
        }
#endif

        //
        // Now, increment iLine, allocate space for the next line, and set its
        // starting point
        //
        iLine++;

        if (!fUserTyping || (iLine > ped->cLines - 1) || (ped->chLines[iLine] != ichLineEnd)) 
        {
            //
            // The line break occured in a different place than before.
            //
            if (!fLineBroken) 
            {
                //
                // Since we haven't broken a line before, just set the min
                // break line.
                //
                fLineBroken = TRUE;

                if (ichLineEndBeforeCRLF == ichLineEnd)
                {
                    minCchBreak = maxCchBreak = (ichLineEnd ? ichLineEnd - 1 : 0);
                }
                else
                {
                    minCchBreak = maxCchBreak = ichLineEndBeforeCRLF;
                }
            }

            maxCchBreak = max(maxCchBreak, ichLineEnd);

            Edit_Unlock(ped);

            //
            // Now insert the new line into the array
            //
            if (!EditML_InsertchLine(ped, iLine, ichLineEnd, (BOOL)(cchDelta != 0)))
            {
                goto EndUp;
            }

            ptext = Edit_Lock(ped);
        } 
        else 
        {
            maxCchBreak = ped->chLines[iLine];

            //
            // Quick escape
            //
            goto UnlockAndEndUp;
        }

        ichLineStart = ichLineEnd;
    }


    if (iLine != ped->cLines) 
    {
        TraceMsg(TF_STANDARD, "Edit: chLines[%d] is being cleared.", iLine);
        ped->cLines = iLine;
        ped->chLines[ped->cLines] = 0;
    }

    //
    // Note that we incremented iLine towards the end of the while loop so, the
    // index, iLine, is actually equal to the line count
    //
    if (ped->cch && AWCOMPARECHAR(ped, ptext + (ped->cch - 1)*ped->cbChar, 0x0A) &&
            ped->chLines[ped->cLines - 1] < ped->cch) 
    {
        //
        // Make sure last line has no crlf in it
        //
        if (!fLineBroken) 
        {
            //
            // Since we haven't broken a line before, just set the min break
            // line.
            //
            fLineBroken = TRUE;
            minCchBreak = ped->cch - 1;
        }

        maxCchBreak = max(maxCchBreak, ichLineEnd);
        Edit_Unlock(ped);
        EditML_InsertchLine(ped, iLine, ped->cch, FALSE);
        EditML_SanityCheck(ped);
    } 
    else
    {
UnlockAndEndUp:
        Edit_Unlock(ped);
    }

EndUp:
    Edit_ReleaseDC(ped, hdc, TRUE);

    if (pll)
    {
        *pll = minCchBreak;
    }

    if (phl)
    {
        *phl = maxCchBreak;
    }

UpdateScroll:
    EditML_Scroll(ped, FALSE, ML_REFRESH, 0, TRUE);
    EditML_Scroll(ped, TRUE,  ML_REFRESH, 0, TRUE);

    EditML_SanityCheck(ped);

    return;
}


//---------------------------------------------------------------------------//
//
// EditML_Paint()
// 
// Response to WM_PAINT message.
//
VOID EditML_Paint(PED ped, HDC hdc, LPRECT lprc)
{
    HFONT  hOldFont;
    ICH    imin;
    ICH    imax;
    HBRUSH hbr;
    BOOL   fNeedDelete = FALSE;

    //
    // Do we need to draw the border ourself for old apps?
    //
    if (ped->fFlatBorder)
    {
        RECT    rcT;
        ULONG   ulStyle;
        INT     cxBorder;
        INT     cyBorder;
        INT     cxFrame;
        INT     cyFrame;

        ulStyle = GET_STYLE(ped);
        cxBorder = GetSystemMetrics(SM_CXBORDER);
        cyBorder = GetSystemMetrics(SM_CYBORDER);
        cxFrame  = GetSystemMetrics(SM_CXFRAME);
        cyFrame  = GetSystemMetrics(SM_CYFRAME);

        GetClientRect(ped->hwnd, &rcT);
        if (ulStyle & WS_SIZEBOX)
        {
            InflateRect(&rcT, cxBorder - cxFrame, cyBorder - cyFrame);
        }
        DrawFrame(hdc, &rcT, 1, DF_WINDOWFRAME);
    }

    Edit_SetClip(ped, hdc, (BOOL) (ped->xOffset == 0));

    if (ped->hFont)
    {
        hOldFont = SelectObject(hdc, ped->hFont);
    }

    if (!lprc) 
    {
        //
        // no partial rect given -- draw all text
        //
        imin = 0;
        imax = ped->cch;
    } 
    else 
    {
        //
        // only draw pertinent text
        //
        imin = (ICH) EditML_MouseToIch(ped, hdc, ((LPPOINT) &lprc->left), NULL) - 1;
        if (imin == -1)
        {
            imin = 0;
        }

        //
        // HACK_ALERT:
        // The 3 is required here because, EditML_MouseToIch() returns decremented
        // value; We must fix EditML_MouseToIch.
        //
        imax = (ICH) EditML_MouseToIch(ped, hdc, ((LPPOINT) &lprc->right), NULL) + 3;
        if (imax > ped->cch)
        {
            imax = ped->cch;
        }
    }

    hbr = Edit_GetBrush(ped, hdc, &fNeedDelete);
    if (hbr)
    {
        RECT rc;
        GetClientRect(ped->hwnd, &rc);
        FillRect(hdc, &rc, hbr);

        if (fNeedDelete)
        {
            DeleteObject(hbr);
        }
    }

    EditML_DrawText(ped, hdc, imin, imax, FALSE);

    if (ped->hFont)
    {
        SelectObject(hdc, hOldFont);
    }
}


//---------------------------------------------------------------------------//
//
// EditML_KeyDown AorW
// 
// Handles cursor movement and other VIRT KEY stuff. keyMods allows
// us to make EditML_KeyDownHandler calls and specify if the modifier keys (shift
// and control) are up or down. If keyMods == 0, we get the keyboard state
// using GetKeyState(VK_SHIFT) etc. Otherwise, the bits in keyMods define the
// state of the shift and control keys.
//
VOID EditML_KeyDown(PED ped, UINT virtKeyCode, int keyMods)
{
    HDC hdc;
    BOOL prevLine;
    POINT mousePt;
    int defaultDlgId;
    int iScrollAmt;

    //
    // Variables we will use for redrawing the updated text
    //

    //
    // new selection is specified by newMinSel, newMaxSel
    //
    ICH newMaxSel = ped->ichMaxSel;
    ICH newMinSel = ped->ichMinSel;

    //
    // Flags for drawing the updated text
    //
    BOOL changeSelection = FALSE;

    //
    // Comparisons we do often
    //
    BOOL MinEqMax = (newMaxSel == newMinSel);
    BOOL MinEqCar = (ped->ichCaret == newMinSel);
    BOOL MaxEqCar = (ped->ichCaret == newMaxSel);

    //
    // State of shift and control keys.
    //
    int scState;

    if (ped->fMouseDown) 
    {
        //
        // If we are in the middle of a mousedown command, don't do anything.
        //
        return;
    }

    if (ped->hwndBalloon)
    {
        Edit_HideBalloonTip(ped->hwnd);
    }

    scState = Edit_GetModKeys(keyMods);

    switch (virtKeyCode) 
    {
    case VK_ESCAPE:
        if (ped->fInDialogBox) 
        {
            //
            // This condition is removed because, if the dialogbox does not
            // have a CANCEL button and if ESC is hit when focus is on a
            // ML edit control the dialogbox must close whether it has cancel
            // button or not to be consistent with SL edit control;
            // DefDlgProc takes care of the disabled CANCEL button case.
            // Fix for Bug #4123 -- 02/07/91 -- SANKAR --
            //
#if 0
            if (GetDlgItem(ped->hwndParent, IDCANCEL))
#endif
                //
                // User hit ESC...Send a close message (which in turn sends a
                // cancelID to the app in DefDialogProc...
                //
                PostMessage(ped->hwndParent, WM_CLOSE, 0, 0L);
        }

        return;

    case VK_RETURN:
        if (ped->fInDialogBox) 
        {
            //
            // If this multiline edit control is in a dialog box, then we want
            // the RETURN key to be sent to the default dialog button (if there
            // is one). CTRL-RETURN will insert a RETURN into the text. Note
            // that CTRL-RETURN automatically translates into a linefeed (0x0A)
            // and in the EditML_CharHandler, we handle this as if a return was
            // entered.
            //
            if (scState != CTRLDOWN) 
            {
                if (GET_STYLE(ped) & ES_WANTRETURN) 
                {
                    //
                    // This edit control wants cr to be inserted so break out of
                    // case.
                    //
                    return;
                }

                defaultDlgId = (int)(DWORD)LOWORD(SendMessage(ped->hwndParent,
                        DM_GETDEFID, 0, 0L));
                if (defaultDlgId) 
                {
                    HWND hwnd = GetDlgItem(ped->hwndParent, defaultDlgId);
                    if (hwnd) 
                    {
                        SendMessage(ped->hwndParent, WM_NEXTDLGCTL, (WPARAM)hwnd, 1L);
                        if (!ped->fFocus)
                        {
                            PostMessage(hwnd, WM_KEYDOWN, VK_RETURN, 0L);
                        }
                    }
                }
            }

            return;
        }

        break;

    case VK_TAB:

        //
        // If this multiline edit control is in a dialog box, then we want the
        // TAB key to take you to the next control, shift TAB to take you to the
        // previous control. We always want CTRL-TAB to insert a tab into the
        // edit control regardless of weather or not we're in a dialog box.
        //
        if (scState == CTRLDOWN)
        {
            EditML_Char(ped, virtKeyCode, keyMods);
        }
        else if (ped->fInDialogBox)
        {
            SendMessage(ped->hwndParent, WM_NEXTDLGCTL, scState == SHFTDOWN, 0L);
        }

        return;

    case VK_LEFT:

        //
        // If the caret isn't at the beginning, we can move left
        //
        if (ped->ichCaret) 
        {
            //
            // Get new caret pos.
            //
            if (scState & CTRLDOWN) 
            {
                //
                // Move caret word left
                //
                Edit_Word(ped, ped->ichCaret, TRUE, &ped->ichCaret, NULL);
            } 
            else 
            {
                if (ped->pLpkEditCallout) 
                {
                    ped->ichCaret = Edit_MoveSelectionRestricted(ped, ped->ichCaret, TRUE);
                } 
                else 
                {
                    //
                    // Move caret char left
                    //
                    ped->ichCaret = Edit_MoveSelection(ped, ped->ichCaret, TRUE);
                }
            }

            //
            // Get new selection
            //
            if (scState & SHFTDOWN) 
            {
                if (MaxEqCar && !MinEqMax) 
                {
                    //
                    // Reduce selection
                    //
                    newMaxSel = ped->ichCaret;

                    UserAssert(newMinSel == ped->ichMinSel);
                }
                else 
                {
                    //
                    // Extend selection
                    //
                    newMinSel = ped->ichCaret;
                }
            } 
            else 
            {
                //
                // Clear selection
                //
                newMaxSel = newMinSel = ped->ichCaret;
            }

            changeSelection = TRUE;
        } 
        else 
        {
            //
            // If the user tries to move left and we are at the 0th
            // character and there is a selection, then cancel the
            // selection.
            //
            if ( (ped->ichMaxSel != ped->ichMinSel) &&
                !(scState & SHFTDOWN) ) 
            {
                changeSelection = TRUE;
                newMaxSel = newMinSel = ped->ichCaret;
            }
        }

        break;

    case VK_RIGHT:

        //
        // If the caret isn't at the end, we can move right.
        //
        if (ped->ichCaret < ped->cch) 
        {
            //
            // Get new caret pos.
            //
            if (scState & CTRLDOWN) 
            {
                //
                // Move caret word right
                //
                Edit_Word(ped, ped->ichCaret, FALSE, NULL, &ped->ichCaret);
            } 
            else 
            {
                //
                // Move caret char right
                //
                if (ped->pLpkEditCallout) 
                {
                    ped->ichCaret = Edit_MoveSelectionRestricted(ped, ped->ichCaret, FALSE);
                } 
                else 
                {
                    ped->ichCaret = Edit_MoveSelection(ped, ped->ichCaret, FALSE);
                }
            }

            //
            // Get new selection.
            //
            if (scState & SHFTDOWN) 
            {
                if (MinEqCar && !MinEqMax) 
                {
                    //
                    // Reduce selection
                    //
                    newMinSel = ped->ichCaret;

                    UserAssert(newMaxSel == ped->ichMaxSel);
                }
                else 
                {
                    //
                    // Extend selection
                    //
                    newMaxSel = ped->ichCaret;
                }
            } 
            else 
            {
                //
                // Clear selection
                //
                newMaxSel = newMinSel = ped->ichCaret;
            }

            changeSelection = TRUE;
        } 
        else 
        {
            //
            // If the user tries to move right and we are at the last
            // character and there is a selection, then cancel the
            // selection.
            //
            if ( (ped->ichMaxSel != ped->ichMinSel) &&
                !(scState & SHFTDOWN) ) 
            {
                newMaxSel = newMinSel = ped->ichCaret;
                changeSelection = TRUE;
            }
        }

        break;

    case VK_UP:
    case VK_DOWN:
        if (ped->cLines - 1 != ped->iCaretLine &&
                ped->ichCaret == ped->chLines[ped->iCaretLine + 1])
        {
            prevLine = TRUE;
        }
        else
        {
            prevLine = FALSE;
        }

        hdc = Edit_GetDC(ped, TRUE);
        EditML_IchToXYPos(ped, hdc, ped->ichCaret, prevLine, &mousePt);
        Edit_ReleaseDC(ped, hdc, TRUE);
        mousePt.y += 1 + (virtKeyCode == VK_UP ? -ped->lineHeight : ped->lineHeight);

        if (!(scState & CTRLDOWN)) 
        {
            //
            // Send fake mouse messages to handle this
            // If VK_SHIFT is down, extend selection & move caret up/down
            // 1 line.  Otherwise, clear selection & move caret.
            //
            EditML_MouseMotion(ped, WM_LBUTTONDOWN,
                            !(scState & SHFTDOWN) ? 0 : MK_SHIFT, &mousePt);
            EditML_MouseMotion(ped, WM_LBUTTONUP,
                            !(scState & SHFTDOWN) ? 0 : MK_SHIFT, &mousePt);
        }

        break;

    case VK_HOME:
        //
        // Update caret.
        //
        if (scState & CTRLDOWN) 
        {
            //
            // Move caret to beginning of text.
            //
            ped->ichCaret = 0;
        } 
        else 
        {
            //
            // Move caret to beginning of line.
            //
            ped->ichCaret = ped->chLines[ped->iCaretLine];
        }

        //
        // Update selection.
        //
        newMinSel = ped->ichCaret;

        if (scState & SHFTDOWN) 
        {
            if (MaxEqCar && !MinEqMax) 
            {
                if (scState & CTRLDOWN)
                {
                    newMaxSel = ped->ichMinSel;
                }
                else 
                {
                    newMinSel = ped->ichMinSel;
                    newMaxSel = ped->ichCaret;
                }
            }
        } 
        else 
        {
            //
            // Clear selection
            //
            newMaxSel = ped->ichCaret;
        }

        changeSelection = TRUE;

        break;

    case VK_END:
        //
        // Update caret.
        //
        if (scState & CTRLDOWN) 
        {
            //
            // Move caret to end of text.
            //
            ped->ichCaret = ped->cch;
        } 
        else 
        {
            //
            // Move caret to end of line.
            //
            ped->ichCaret = ped->chLines[ped->iCaretLine] +
                EditML_Line(ped, ped->iCaretLine);
        }

        //
        // Update selection.
        //
        newMaxSel = ped->ichCaret;

        if (scState & SHFTDOWN) 
        {
            if (MinEqCar && !MinEqMax) 
            {
                //
                // Reduce selection
                //
                if (scState & CTRLDOWN) 
                {
                    newMinSel = ped->ichMaxSel;
                } 
                else 
                {
                    newMinSel = ped->ichCaret;
                    newMaxSel = ped->ichMaxSel;
                }
            }
        } 
        else 
        {
            //
            // Clear selection
            //
            newMinSel = ped->ichCaret;
        }

        changeSelection = TRUE;

        break;

    //
    // FE_IME // EC_INSERT_COMPOSITION_CHAR : EditML_KeyDown() : VK_HANJA support
    //
    case VK_HANJA:
        if ( HanjaKeyHandler( ped ) ) 
        {
            changeSelection = TRUE;
            newMinSel = ped->ichCaret;
            newMaxSel = ped->ichCaret + (ped->fAnsi ? 2 : 1);
        }

        break;

    case VK_PRIOR:
    case VK_NEXT:
        if (!(scState & CTRLDOWN)) 
        {
            //
            // Vertical scroll by one visual screen
            //
            hdc = Edit_GetDC(ped, TRUE);
            EditML_IchToXYPos(ped, hdc, ped->ichCaret, FALSE, &mousePt);
            Edit_ReleaseDC(ped, hdc, TRUE);
            mousePt.y += 1;

            SendMessage(ped->hwnd, WM_VSCROLL, virtKeyCode == VK_PRIOR ? SB_PAGEUP : SB_PAGEDOWN, 0L);

            //
            // Move the cursor there
            //
            EditML_MouseMotion(ped, WM_LBUTTONDOWN, !(scState & SHFTDOWN) ? 0 : MK_SHIFT, &mousePt);
            EditML_MouseMotion(ped, WM_LBUTTONUP,   !(scState & SHFTDOWN) ? 0 : MK_SHIFT, &mousePt);

        } 
        else 
        {
            //
            // Horizontal scroll by one screenful minus one char
            //
            iScrollAmt = ((ped->rcFmt.right - ped->rcFmt.left) / ped->aveCharWidth) - 1;
            if (virtKeyCode == VK_PRIOR)
            {
                //
                // For previous page
                //
                iScrollAmt *= -1;
            }

            SendMessage(ped->hwnd, WM_HSCROLL, MAKELONG(EM_LINESCROLL, iScrollAmt), 0);

            break;
        }

        break;

    case VK_DELETE:
        if (ped->fReadOnly)
        {
            break;
        }

        switch (scState) 
        {
        case NONEDOWN:

            //
            // Clear selection. If no selection, delete (clear) character
            // right
            //
            if ((ped->ichMaxSel < ped->cch) && (ped->ichMinSel == ped->ichMaxSel)) 
            {
                //
                // Move cursor forwards and send a backspace message...
                //
                if (ped->pLpkEditCallout) 
                {
                    ped->ichMinSel = ped->ichCaret;
                    ped->ichMaxSel = Edit_MoveSelectionRestricted(ped, ped->ichCaret, FALSE);
                } 
                else 
                {
                    ped->ichCaret = Edit_MoveSelection(ped, ped->ichCaret, FALSE);
                    ped->ichMaxSel = ped->ichMinSel = ped->ichCaret;
                }

                goto DeleteAnotherChar;
            }

            break;

        case SHFTDOWN:

            //
            // CUT selection ie. remove and copy to clipboard, or if no
            // selection, delete (clear) character left.
            //
            if (ped->ichMinSel == ped->ichMaxSel) 
            {
                goto DeleteAnotherChar;
            } 
            else 
            {
                SendMessage(ped->hwnd, WM_CUT, (UINT)0, 0L);
            }

            break;

        case CTRLDOWN:

            //
            // Clear selection, or delete to end of line if no selection
            //
            if ((ped->ichMaxSel < ped->cch) && (ped->ichMinSel == ped->ichMaxSel)) 
            {
                ped->ichMaxSel = ped->ichCaret = ped->chLines[ped->iCaretLine] +
                                                 EditML_Line(ped, ped->iCaretLine);
            }

            break;
        }

        if (!(scState & SHFTDOWN) && (ped->ichMinSel != ped->ichMaxSel)) 
        {

DeleteAnotherChar:
            if (Is400Compat(UserGetVersion())) 
            {
                EditML_Char(ped, VK_BACK, 0);
            } 
            else 
            {
                SendMessage(ped->hwnd, WM_CHAR, VK_BACK, 0);
            }
        }

        //
        // No need to update text or selection since BACKSPACE message does it
        // for us.
        //
        break;

    case VK_INSERT:
        if (scState == CTRLDOWN || scState == SHFTDOWN) 
        {
            //
            // if CTRLDOWN Copy current selection to clipboard
            //

            //
            // if SHFTDOWN Paste clipboard
            //
            SendMessage(ped->hwnd, (UINT)(scState == CTRLDOWN ? WM_COPY : WM_PASTE), 0, 0);
        }

        break;
    }

    if (changeSelection) 
    {
        hdc = Edit_GetDC(ped, FALSE);
        EditML_ChangeSelection(ped, hdc, newMinSel, newMaxSel);

        //
        // Set the caret's line
        //
        ped->iCaretLine = EditML_IchToLine(ped, ped->ichCaret);

        if (virtKeyCode == VK_END &&
                // Next line: Win95 Bug#11822, EditControl repaint (Sankar)
                (ped->ichCaret == ped->chLines[ped->iCaretLine]) &&
                ped->ichCaret < ped->cch &&
                ped->fWrap && ped->iCaretLine > 0) 
        {
            LPSTR pText = Edit_Lock(ped);

            //
            // Handle moving to the end of a word wrapped line. This keeps the
            // cursor from falling to the start of the next line if we have word
            // wrapped and there is no CRLF.
            //
            if ( ped->fAnsi ) 
            {
                if (*(WORD UNALIGNED *)(pText + ped->chLines[ped->iCaretLine] - 2) != 0x0A0D) 
                {
                    ped->iCaretLine--;
                }
            } 
            else 
            {
                if (*(DWORD UNALIGNED *)(pText +
                     (ped->chLines[ped->iCaretLine] - 2)*ped->cbChar) != 0x000A000D) 
                {
                    ped->iCaretLine--;
                }
            }

            Edit_Unlock(ped);
        }

        //
        // Since drawtext sets the caret position
        //
        EditML_SetCaretPosition(ped, hdc);
        Edit_ReleaseDC(ped, hdc, FALSE);

        //
        // Make sure we can see the cursor
        //
        EditML_EnsureCaretVisible(ped);
    }
}


//---------------------------------------------------------------------------//
// 
// EditML_Char
//
// Handles character and virtual key input
//
VOID EditML_Char(PED ped, DWORD keyValue, int keyMods)
{
    WCHAR keyPress;
    BOOL  updateText = FALSE;

    //
    // keyValue is either:
    // a Virtual Key (eg: VK_TAB, VK_ESCAPE, VK_BACK)
    // a character (Unicode or "ANSI")
    //
    if (ped->fAnsi)
    {
        keyPress = LOBYTE(keyValue);
    }
    else
    {
        keyPress = LOWORD(keyValue);
    }

    if (ped->fMouseDown || keyPress == VK_ESCAPE) 
    {
        //
        // If we are in the middle of a mousedown command, don't do anything.
        // Also, just ignore it if we get a translated escape key which happens
        // with multiline edit controls in a dialog box.
        //
        return;
    }

    Edit_InOutReconversionMode(ped, FALSE);

    {
        int scState;
        scState = Edit_GetModKeys(keyMods);

        if (ped->fInDialogBox && scState != CTRLDOWN) 
        {
            //
            // If this multiline edit control is in a dialog box, then we want the
            // TAB key to take you to the next control, shift TAB to take you to the
            // previous control, and CTRL-TAB to insert a tab into the edit control.
            // We moved the focus when we received the keydown message so we will
            // ignore the TAB key now unless the ctrl key is down. Also, we want
            // CTRL-RETURN to insert a return into the text and RETURN to be sent to
            // the default button.
            //
            if (keyPress == VK_TAB || (keyPress == VK_RETURN && !(GET_STYLE(ped) & ES_WANTRETURN)))
            {
                return;
            }
        }

        //
        // Allow CTRL+C to copy from a read only edit control
        // Ignore all other keys in read only controls
        //
        if ((ped->fReadOnly) && !((keyPress == 3) && (scState == CTRLDOWN))) 
        {
            return;
        }
    }

    switch (keyPress) 
    {
    case 0x0A: 
        // linefeed
        keyPress = VK_RETURN;

        //
        // FALL THRU
        //

    case VK_RETURN:
    case VK_TAB:
    case VK_BACK:
DeleteSelection:
        if (EditML_DeleteText(ped))
        {
            updateText = TRUE;
        }

        break;

    default:
        if (keyPress >= TEXT(' ')) 
        {
            //
            // If this is in [a-z],[A-Z] and we are an ES_NUMBER
            // edit field, bail.
            //
            if (Is400Compat(UserGetVersion()) && GET_STYLE(ped) & ES_NUMBER) 
            {
                if (!Edit_IsCharNumeric(ped, keyPress)) 
                {
                    Edit_ShowBalloonTipWrap(ped->hwnd, IDS_NUMERIC_TITLE, IDS_NUMERIC_MSG, TTI_ERROR);
                    goto IllegalChar;
                }
            }

            goto DeleteSelection;
        }

        break;
    }

    //
    // Handle key codes
    //
    switch(keyPress) 
    {
    UINT msg;

    // Ctrl+Z == Undo
    case 26:
        msg = WM_UNDO;
        goto SendEditingMessage;
        break;

    // Ctrl+X == Cut
    case 24:
        if (ped->ichMinSel == ped->ichMaxSel)
        {
            goto IllegalChar;
        }
        else
        {
            msg = WM_CUT;
            goto SendEditingMessage;
        }
        break;

    // Ctrl+C == Copy
    case 3:
        msg = WM_COPY;
        goto SendEditingMessage;
        break;

    // Ctrl+V == Paste
    case 22:
        msg = WM_PASTE;
SendEditingMessage:
        SendMessage(ped->hwnd, msg, 0, 0L);
        break;

    case VK_BACK:
        //
        // Delete any selected text or delete character left if no sel
        //
        if (!updateText && ped->ichMinSel)
        {
            //
            // There was no selection to delete so we just delete
            // character left if available
            //
            ped->ichMinSel = Edit_MoveSelection(ped, ped->ichCaret, TRUE);
            EditML_DeleteText(ped);
        }
        break;

    default:
        if (keyPress == VK_RETURN)
        {
            if (ped->fAnsi)
            {
                keyValue = 0x0A0D;
            }
            else
            {
                keyValue = 0x000A000D;
            }
        }

        if (   keyPress >= TEXT(' ')
            || keyPress == VK_RETURN
            || keyPress == VK_TAB
            || keyPress == 0x1E     // RS - Unicode block separator
            || keyPress == 0x1F     // US - Unicode segment separator
            ) 
        {

            // Don't hide the cursor if someone has capture. 
            if (GetCapture() == NULL)
            {
                SetCursor(NULL);
            }
            if (ped->fAnsi) 
            {
                //
                // check if it's a leading byte of double byte character
                //
                if (Edit_IsDBCSLeadByte(ped,(BYTE)keyPress)) 
                {
                    int DBCSkey;

                    DBCSkey = DbcsCombine(ped->hwnd, keyPress);
                    if ( DBCSkey != 0)
                    {
                        keyValue = DBCSkey;
                    }
                }

                EditML_InsertText(ped, (LPSTR)&keyValue, HIBYTE(keyValue) ? 2 : 1, TRUE);
            } 
            else
            {
                EditML_InsertText(ped, (LPSTR)&keyValue, HIWORD(keyValue) ? 2 : 1, TRUE);
            }

        } 
        else 
        {
IllegalChar:
            MessageBeep(0);
        }
        break;
    }
}


//---------------------------------------------------------------------------//
//
// EditML_PasteText AorW
//
// Pastes a line of text from the clipboard into the edit control
// starting at ped->ichCaret. Updates ichMaxSel and ichMinSel to point to the
// end of the inserted text. Notifies the parent if space cannot be
// allocated. Returns how many characters were inserted.
//
ICH EditML_PasteText(PED ped)
{
    HANDLE hData;
    LPSTR lpchClip;
    ICH cchAdded = 0;
    HCURSOR hCursorOld;

#ifdef UNDO_CLEANUP           // #ifdef Added in Chicago  - johnl
    if (!ped->fAutoVScroll) 
    {
        //
        // Empty the undo buffer if this edit control limits the amount of text
        // the user can add to the window rect. This is so that we can undo this
        // operation if doing in causes us to exceed the window boundaries.
        //
        Edit_EmptyUndo(ped);
    }
#endif

    hCursorOld = SetCursor(LoadCursor(NULL, IDC_WAIT));

    if (!OpenClipboard(ped->hwnd))
    {
        goto PasteExitNoCloseClip;
    }

    if (!(hData = GetClipboardData(ped->fAnsi ? CF_TEXT : CF_UNICODETEXT)) ||
            (GlobalFlags(hData) == GMEM_INVALID_HANDLE)) 
    {
        TraceMsg(TF_STANDARD, "Edit: EditML_PasteText(): couldn't get a valid handle(%x)", hData);
        goto PasteExit;
    }

    //
    // See if any text should be deleted
    //
    EditML_DeleteText(ped);

    lpchClip = GlobalLock(hData);
    if (lpchClip == NULL) 
    {
        TraceMsg(TF_STANDARD, "Edit: EditML_PasteText: USERGLOBALLOCK(%x) failed.", hData);
        goto PasteExit;
    }

    //
    // Get the length of the addition.
    //
    if (ped->fAnsi)
    {
        cchAdded = strlen(lpchClip);
    }
    else
    {
        cchAdded = wcslen((LPWSTR)lpchClip);
    }

    //
    // Insert the text (EditML_InsertText checks line length)
    //
    cchAdded = EditML_InsertText(ped, lpchClip, cchAdded, FALSE);

    GlobalUnlock(hData);

PasteExit:
    CloseClipboard();

PasteExitNoCloseClip:
    SetCursor(hCursorOld);

    return cchAdded;
}


//---------------------------------------------------------------------------//
VOID EditML_MouseMotion(PED ped, UINT message, UINT virtKeyDown, LPPOINT mousePt)
{
    BOOL fChangedSel = FALSE;
    UINT dtScroll = GetDoubleClickTime() / 5;

    HDC hdc = Edit_GetDC(ped, TRUE);

    ICH ichMaxSel = ped->ichMaxSel;
    ICH ichMinSel = ped->ichMinSel;

    ICH mouseCch;
    ICH mouseLine;
    int i, j;
    LONG  ll, lh;

    mouseCch = EditML_MouseToIch(ped, hdc, mousePt, &mouseLine);

    //
    // Save for timer
    //
    ped->ptPrevMouse = *mousePt;
    ped->prevKeys = virtKeyDown;

    switch (message) 
    {
    case WM_LBUTTONDBLCLK:
        //
        // if shift key is down, extend selection to word we double clicked on
        // else clear current selection and select word.
        // LiZ -- 5/5/93
        //
        if (ped->fAnsi && ped->fDBCS) 
        {
            LPSTR pText = Edit_Lock(ped);
            Edit_Word(ped,ped->ichCaret,
                   Edit_IsDBCSLeadByte(ped, *(pText+(ped->ichCaret)))
                        ? FALSE :
                          (ped->ichCaret == ped->chLines[ped->iCaretLine]
                              ? FALSE : TRUE), &ll, &lh);
            Edit_Unlock(ped);
        } 
        else 
        {
            Edit_Word(ped, mouseCch, !(mouseCch == ped->chLines[mouseLine]), &ll, &lh);
        }
        if (!(virtKeyDown & MK_SHIFT)) 
        {
            //
            // If shift key isn't down, move caret to mouse point and clear
            // old selection
            //
            ichMinSel = ll;
            ichMaxSel = ped->ichCaret = lh;
        } 
        else 
        {
            //
            // Shiftkey is down so we want to maintain the current selection
            // (if any) and just extend or reduce it
            //
            if (ped->ichMinSel == ped->ichCaret) 
            {
                ichMinSel = ped->ichCaret = ll;
                Edit_Word(ped, ichMaxSel, TRUE, &ll, &lh);
            } 
            else 
            {
                ichMaxSel = ped->ichCaret = lh;
                Edit_Word(ped, ichMinSel, FALSE, &ll, &lh);
            }
        }

        ped->ichStartMinSel = ll;
        ped->ichStartMaxSel = lh;

        goto InitDragSelect;

    case WM_MOUSEMOVE:
        if (ped->fMouseDown) 
        {
            //
            // Set the system timer to automatically scroll when mouse is
            // outside of the client rectangle. Speed of scroll depends on
            // distance from window.
            //
            i = mousePt->y < 0 ? -mousePt->y : mousePt->y - ped->rcFmt.bottom;
            j = dtScroll - ((UINT)i << 4);
            if (j < 1)
            {
                j = 1;
            }
            SetTimer(ped->hwnd, IDSYS_SCROLL, (UINT)j, NULL);

            fChangedSel = TRUE;

            //
            // Extend selection, move caret right
            //
            if (ped->ichStartMinSel || ped->ichStartMaxSel) 
            {
                //
                // We're in WORD SELECT mode
                //
                BOOL fReverse = (mouseCch <= ped->ichStartMinSel);
                Edit_Word(ped, mouseCch, !fReverse, &ll, &lh);
                if (fReverse) 
                {
                    ichMinSel = ped->ichCaret = ll;
                    ichMaxSel = ped->ichStartMaxSel;
                } 
                else 
                {
                    ichMinSel = ped->ichStartMinSel;
                    ichMaxSel = ped->ichCaret = lh;
                }
            } 
            else if ((ped->ichMinSel == ped->ichCaret) &&
                    (ped->ichMinSel != ped->ichMaxSel))
            {
                //
                // Reduce selection extent
                //
                ichMinSel = ped->ichCaret = mouseCch;
            }
            else
            {
                //
                // Extend selection extent
                //
                ichMaxSel = ped->ichCaret = mouseCch;
            }

            ped->iCaretLine = mouseLine;
        }

        break;

    case WM_LBUTTONDOWN:
        ll = lh = mouseCch;

        if (!(virtKeyDown & MK_SHIFT)) 
        {
            //
            // If shift key isn't down, move caret to mouse point and clear
            // old selection
            //
            ichMinSel = ichMaxSel = ped->ichCaret = mouseCch;
        } 
        else 
        {
            //
            // Shiftkey is down so we want to maintain the current selection
            // (if any) and just extend or reduce it
            //
            if (ped->ichMinSel == ped->ichCaret)
            {
                ichMinSel = ped->ichCaret = mouseCch;
            }
            else
            {
                ichMaxSel = ped->ichCaret = mouseCch;
            }
        }

        ped->ichStartMinSel = ped->ichStartMaxSel = 0;

InitDragSelect:
        ped->iCaretLine = mouseLine;

        ped->fMouseDown = FALSE;
        SetCapture(ped->hwnd);
        ped->fMouseDown = TRUE;
        fChangedSel = TRUE;

        //
        // Set the timer so that we can scroll automatically when the mouse
        // is moved outside the window rectangle.
        //
        SetTimer(ped->hwnd, IDSYS_SCROLL, dtScroll, NULL);
        break;

    case WM_LBUTTONUP:
        if (ped->fMouseDown) 
        {
            //
            // Kill the timer so that we don't do auto mouse moves anymore
            //
            KillTimer(ped->hwnd, IDSYS_SCROLL);
            ReleaseCapture();
            EditML_SetCaretPosition(ped, hdc);
            ped->fMouseDown = FALSE;
        }

        break;
    }


    if (fChangedSel) 
    {
        EditML_ChangeSelection(ped, hdc, ichMinSel, ichMaxSel);
        EditML_EnsureCaretVisible(ped);
    }

    Edit_ReleaseDC(ped, hdc, TRUE);

    if (!ped->fFocus && (message == WM_LBUTTONDOWN)) 
    {
        //
        // If we don't have the focus yet, get it
        //
        SetFocus(ped->hwnd);
    }
}


//---------------------------------------------------------------------------//
LONG EditML_Scroll(PED ped, BOOL fVertical, int cmd, int iAmt, BOOL fRedraw)
{
    SCROLLINFO  si;
    int         dx = 0;
    int         dy = 0;
    BOOL        fIncludeLeftMargin;
    int         newPos;
    int         oldPos;
    BOOL        fUp = FALSE;
    UINT        wFlag;
    DWORD       dwTime = 0;

    if (fRedraw && (cmd != ML_REFRESH)) 
    {
        UpdateWindow(ped->hwnd);
    }

    if (ped->pLpkEditCallout && ped->fRtoLReading && !fVertical
        && ped->maxPixelWidth > ped->rcFmt.right - ped->rcFmt.left)  
    {
        //
        // Horizontal scoll of a right oriented window with a scrollbar.
        // Map the logical xOffset to visual coordinates.
        //
        oldPos = ped->maxPixelWidth
                 - ((int)ped->xOffset + ped->rcFmt.right - ped->rcFmt.left);
    } 
    else
    {
        oldPos = (int) (fVertical ? ped->ichScreenStart : ped->xOffset);
    }

    fIncludeLeftMargin = (ped->xOffset == 0);

    switch (cmd) 
    {
        case ML_REFRESH:
            newPos = oldPos;
            break;

        case EM_GETTHUMB:
            return oldPos;

        case SB_THUMBTRACK:
        case SB_THUMBPOSITION:

            //
            // If the edit contains more than 0xFFFF lines
            // it means that the scrolbar can return a position
            // that cannot fit in a WORD (16 bits), so use
            // GetScrollInfo (which is slower) in this case.
            //
            if (ped->cLines < 0xFFFF) 
            {
                newPos = iAmt;
            } 
            else 
            {
                SCROLLINFO si;

                si.cbSize   = sizeof(SCROLLINFO);
                si.fMask    = SIF_TRACKPOS;

                GetScrollInfo( ped->hwnd, SB_VERT, &si);

                newPos = si.nTrackPos;
            }
            break;

        case SB_TOP:      // == SB_LEFT
            newPos = 0;
            break;

        case SB_BOTTOM:   // == SB_RIGHT
            if (fVertical)
            {
                newPos = ped->cLines;
            }
            else
            {
                newPos = ped->maxPixelWidth;
            }

            break;

        case SB_PAGEUP:   // == SB_PAGELEFT
            fUp = TRUE;

        case SB_PAGEDOWN: // == SB_PAGERIGHT

            if (fVertical)
            {
                iAmt = ped->ichLinesOnScreen - 1;
            }
            else
            {
                iAmt = (ped->rcFmt.right - ped->rcFmt.left) - 1;
            }

            if (iAmt == 0)
            {
                iAmt++;
            }

            if (fUp)
            {
                iAmt = -iAmt;
            }

            goto AddDelta;

        case SB_LINEUP:   // == SB_LINELEFT
            fUp = TRUE;

        case SB_LINEDOWN: // == SB_LINERIGHT

            dwTime = iAmt;

            iAmt = 1;

            if (fUp)
            {
                iAmt = -iAmt;
            }

            //   |             |
            //   |  FALL THRU  |
            //   V             V

        case EM_LINESCROLL:
            if (!fVertical)
            {
                iAmt *= ped->aveCharWidth;
            }

AddDelta:
            newPos = oldPos + iAmt;

            break;

        default:

            return(0L);
    }

    if (fVertical) 
    {
        if (si.nMax = ped->cLines)
        {
            si.nMax--;
        }

        if (!ped->hwndParent ||
            TestWF(ped->hwndParent, WFWIN40COMPAT))
        {
            si.nPage = ped->ichLinesOnScreen;
        }
        else
        {
            si.nPage = 0;
        }

        wFlag = WS_VSCROLL;
    }
    else
    {
        si.nMax  = ped->maxPixelWidth;
        si.nPage = ped->rcFmt.right - ped->rcFmt.left;

        wFlag = WS_HSCROLL;
    }

    if (TESTFLAG(GET_STYLE(ped), wFlag)) 
    {
        si.cbSize = sizeof(SCROLLINFO);
        si.fMask = SIF_ALL | SIF_DISABLENOSCROLL;
        si.nMin  = 0;
        si.nPos = newPos;
        newPos = SetScrollInfo(ped->hwnd, fVertical ? SB_VERT : SB_HORZ,
                                     &si, fRedraw);
    } 
    else 
    {
        //
        // BOGUS -- this is duped code from ScrollBar code
        // but it's for the case when we want to limit the position without
        // actually having the scroll bar
        //
        int iMaxPos;

        //
        // Clip page to 0, range + 1
        //
        si.nPage = max(min((int)si.nPage, si.nMax + 1), 0);


        iMaxPos = si.nMax - (si.nPage ? si.nPage - 1 : 0);
        newPos = min(max(newPos, 0), iMaxPos);
    }

    oldPos -= newPos;

    if (!oldPos)
    {
        return 0;
    }


    if (ped->pLpkEditCallout && ped->fRtoLReading && !fVertical
        && ped->maxPixelWidth > ped->rcFmt.right - ped->rcFmt.left) 
    {
        //
        // Map visual oldPos and newPos back to logical coordinates
        //
        newPos = ped->maxPixelWidth
                 - (newPos + ped->rcFmt.right - ped->rcFmt.left);
        oldPos = -oldPos;
        if (newPos<0) 
        {
            //
            // Compensate for scroll bar returning pos > max-page
            //
            oldPos += newPos;
            newPos=0;
        }
    }

    if (fVertical) 
    {
        ped->ichScreenStart = newPos;
        dy = oldPos * ped->lineHeight;
    } 
    else 
    {
        ped->xOffset = newPos;
        dx = oldPos;
    }

    if (cmd != SB_THUMBTRACK)
    {
        //
        // We don't want to notify the parent of thumbtracking since they might
        // try to set the thumb position to something bogus.
        // NOTEPAD used to be guilty of this -- but I rewrote it so it's not.
        // The question is WHO ELSE does this? (jeffbog)
        //
        Edit_NotifyParent(ped, fVertical ? EN_VSCROLL : EN_HSCROLL);
    }

    if (fRedraw && IsWindowVisible(ped->hwnd)) 
    {
        RECT    rc;
        RECT    rcUpdate;
        RECT    rcClipRect;
        HDC     hdc;
        HBRUSH  hbr = NULL;
        BOOL    fNeedDelete = FALSE;
        

        GetClientRect(ped->hwnd, &rc);
        CopyRect(&rcClipRect, &ped->rcFmt);

        if (fVertical) 
        {
            rcClipRect.left -= ped->wLeftMargin;
            rcClipRect.right += ped->wRightMargin;
        }

        IntersectRect(&rc, &rc, &rcClipRect);
        rc.bottom++;

        //
        // Chicago has this HideCaret but there doesn't appear to be a
        // corresponding ShowCaret, so we lose the Caret under NT when the
        // EC scrolls - Johnl
        //
         
        // HideCaret(ped->hwnd);

        hdc = Edit_GetDC(ped, FALSE);
        Edit_SetClip(ped, hdc, fIncludeLeftMargin);
        if (ped->hFont)
        {
            SelectObject(hdc, ped->hFont);
        }

        hbr = Edit_GetBrush(ped, hdc, &fNeedDelete);
        if (hbr && fNeedDelete)
        {
            DeleteObject(hbr);
        }

        if (ped->pLpkEditCallout && !fVertical) 
        {
            //
            // Horizontal scroll with complex script support
            //
            int xFarOffset = ped->xOffset + ped->rcFmt.right - ped->rcFmt.left;

            rc = ped->rcFmt;
            if (dwTime != 0)
            {
                ScrollWindowEx(ped->hwnd, ped->fRtoLReading ? -dx : dx, dy, NULL, NULL, NULL,
                        &rcUpdate, MAKELONG(SW_SMOOTHSCROLL | SW_SCROLLCHILDREN, dwTime));
            }
            else
            {
                ScrollDC(hdc, ped->fRtoLReading ? -dx : dx, dy,
                               &rc, &rc, NULL, &rcUpdate);
            }

            //
            // Handle margins: Blank if clipped by horizontal scrolling,
            // display otherwise.
            //
            if (ped->wLeftMargin) 
            {
                rc.left  = ped->rcFmt.left - ped->wLeftMargin;
                rc.right = ped->rcFmt.left;
                if (   (ped->format != ES_LEFT)   // Always display margin for centred or far-aligned text
                    ||  // Display LTR left margin if first character fully visible
                        (!ped->fRtoLReading && ped->xOffset == 0)
                    ||  // Display RTL left margin if last character fully visible
                        (ped->fRtoLReading && xFarOffset >= ped->maxPixelWidth)) 
                {
                    UnionRect(&rcUpdate, &rcUpdate, &rc);
                } 
                else 
                {
                    ExtTextOutW(hdc, rc.left, rc.top,
                        ETO_CLIPPED | ETO_OPAQUE | ETO_GLYPH_INDEX,
                        &rc, L"", 0, 0L);
                }
            }

            if (ped->wRightMargin) 
            {
                rc.left  = ped->rcFmt.right;
                rc.right = ped->rcFmt.right + ped->wRightMargin;
                if (   (ped->format != ES_LEFT)   // Always display margin for centred or far-aligned text
                    ||  // Display RTL right margin if first character fully visible
                        (ped->fRtoLReading && ped->xOffset == 0)
                    ||  // Display LTR right margin if last character fully visible
                        (!ped->fRtoLReading && xFarOffset >= ped->maxPixelWidth)) 
                {
                    UnionRect(&rcUpdate, &rcUpdate, &rc);
                } 
                else 
                {
                    ExtTextOutW(hdc, rc.left, rc.top,
                        ETO_CLIPPED | ETO_OPAQUE | ETO_GLYPH_INDEX,
                        &rc, L"", 0, 0L);
                }
            }
        } 
        else 
        {
            if (dwTime != 0)
            {
                ScrollWindowEx(ped->hwnd, dx, dy, NULL, NULL, NULL,
                        &rcUpdate, MAKELONG(SW_SMOOTHSCROLL | SW_SCROLLCHILDREN, dwTime));
            }
            else
            {
                ScrollDC(hdc, dx, dy, &rc, &rc, NULL, &rcUpdate);
            }

            //
            // If we need to wipe out the left margin area
            //
            if (ped->wLeftMargin && !fVertical) 
            {
                //
                // Calculate the rectangle to be wiped out
                //
                rc.right = rc.left;
                rc.left = max(0, ped->rcFmt.left - (LONG)ped->wLeftMargin);
                if (rc.left < rc.right) 
                {
                    if (fIncludeLeftMargin && (ped->xOffset != 0)) 
                    {
                        ExtTextOutW(hdc, rc.left, rc.top, ETO_CLIPPED | ETO_OPAQUE,
                            &rc, L"", 0, 0L);
                    } 
                    else
                    {
                        if((!fIncludeLeftMargin) && (ped->xOffset == 0))
                        {
                            UnionRect(&rcUpdate, &rcUpdate, &rc);
                        }
                    }
                }
            }
        }

        EditML_SetCaretPosition(ped,hdc);

        Edit_ReleaseDC(ped, hdc, FALSE);
        InvalidateRect(ped->hwnd, &rcUpdate, TRUE);
        UpdateWindow(ped->hwnd);
    }

    return MAKELONG(-oldPos, 1);
}


//---------------------------------------------------------------------------//
//
// EditML_SetFocus AorW
//
// Gives the edit control the focus and notifies the parent
// EN_SETFOCUS.
//
void EditML_SetFocus(PED ped)
{
    HDC hdc;
    INT cxCaret;

    SystemParametersInfo(SPI_GETCARETWIDTH, 0, (LPVOID)&cxCaret, 0);

    if (!ped->fFocus) 
    {
        ped->fFocus = TRUE;
        InvalidateRect(ped->hwnd, NULL, TRUE);

        hdc = Edit_GetDC(ped, TRUE);

        //
        // Draw the caret. We need to do this even if the window is hidden
        // because in dlg box initialization time we may set the focus to a
        // hidden edit control window. If we don't create the caret etc, it will
        // never end up showing properly.
        //
        if (ped->pLpkEditCallout) 
        {
            ped->pLpkEditCallout->EditCreateCaret((PED0)ped, hdc, cxCaret, ped->lineHeight, 0);
        }
        else 
        {
            CreateCaret(ped->hwnd, (HBITMAP)NULL, cxCaret, ped->lineHeight);
        }
        ShowCaret(ped->hwnd);
        EditML_SetCaretPosition(ped, hdc);

        //
        // Show the current selection. Only if the selection was hidden when we
        // lost the focus, must we invert (show) it.
        //
        if (!ped->fNoHideSel && ped->ichMinSel != ped->ichMaxSel &&
                IsWindowVisible(ped->hwnd))
        {
            EditML_DrawText(ped, hdc, ped->ichMinSel, ped->ichMaxSel, TRUE);
        }

        Edit_ReleaseDC(ped, hdc, TRUE);

    }

#if 0
    EditML_EnsureCaretVisible(ped);
#endif

    //
    // Notify parent we have the focus
    //
    Edit_NotifyParent(ped, EN_SETFOCUS);
}


//---------------------------------------------------------------------------//
//
// EditML_KillFocus AorW
//
// The edit control loses the focus and notifies the parent via
// EN_KILLFOCUS.
//
VOID EditML_KillFocus(PED ped)
{
    HDC hdc;

    //
    // Reset the wheel delta count.
    //

    if (ped->fFocus) 
    {
        ped->fFocus = 0;

        //
        // Do this only if we still have the focus. But we always notify the
        // parent that we lost the focus whether or not we originally had the
        // focus.
        //

        //
        // Hide the current selection if needed
        //
#ifdef _USE_DRAW_THEME_TEXT_
        if (((!ped->fNoHideSel && ped->ichMinSel != ped->ichMaxSel &&
            IsWindowVisible(ped->hwnd))) || ped->hTheme) 
        {
            hdc = Edit_GetDC(ped, FALSE);
            if ( !ped->hTheme )
            {
                EditML_DrawText(ped, hdc, ped->ichMinSel, ped->ichMaxSel, TRUE);
            }
            else
            {
                InvalidateRect(ped->hwnd, NULL, TRUE);
            }
            Edit_ReleaseDC(ped, hdc, FALSE);
        }
#else
        if (((!ped->fNoHideSel && ped->ichMinSel != ped->ichMaxSel &&
            IsWindowVisible(ped->hwnd)))) 
        {
            hdc = Edit_GetDC(ped, FALSE);

            EditML_DrawText(ped, hdc, ped->ichMinSel, ped->ichMaxSel, TRUE);

            Edit_ReleaseDC(ped, hdc, FALSE);
        }
#endif // _USE_DRAW_THEME_TEXT_

        //
        // Destroy the caret
        //
        DestroyCaret();
    }

    //
    // Notify parent that we lost the focus.
    //
    Edit_NotifyParent(ped, EN_KILLFOCUS);
}


//---------------------------------------------------------------------------//
//
// EditML_EnsureCaretVisible AorW
// 
// Scrolls the caret into the visible region.
// Returns TRUE if scrolling was done else return s FALSE.
//
BOOL EditML_EnsureCaretVisible(PED ped)
{
    UINT   iLineMax;
    int    xposition;
    BOOL   fPrevLine;
    HDC    hdc;
    BOOL   fVScroll = FALSE;
    BOOL   fHScroll = FALSE;

    if (IsWindowVisible(ped->hwnd)) 
    {
        int iAmt;
        int iFmtWidth = ped->rcFmt.right - ped->rcFmt.left;

        if (ped->fAutoVScroll) 
        {
            iLineMax = ped->ichScreenStart + ped->ichLinesOnScreen - 1;

            if (fVScroll = (ped->iCaretLine > iLineMax))
            {
                iAmt = iLineMax;
            }
            else if (fVScroll = (ped->iCaretLine < ped->ichScreenStart))
            {
                iAmt = ped->ichScreenStart;
            }

            if (fVScroll)
            {
                EditML_Scroll(ped, TRUE, EM_LINESCROLL, ped->iCaretLine - iAmt, TRUE);
            }
        }

        if (ped->fAutoHScroll && ((int) ped->maxPixelWidth > iFmtWidth)) 
        {
            POINT pt;

            //
            // Get the current position of the caret in pixels
            //
            if ((UINT) (ped->cLines - 1) != ped->iCaretLine &&
                ped->ichCaret == ped->chLines[ped->iCaretLine + 1])
            {
                fPrevLine = TRUE;
            }
            else
            {
                fPrevLine = FALSE;
            }

            hdc = Edit_GetDC(ped,TRUE);
            EditML_IchToXYPos(ped, hdc, ped->ichCaret, fPrevLine, &pt);
            Edit_ReleaseDC(ped, hdc, TRUE);
            xposition = pt.x;

            //
            // Remember, EditML_IchToXYPos returns coordinates with respect to the
            // top left pixel displayed on the screen.  Thus, if xPosition < 0,
            // it means xPosition is less than current ped->xOffset.
            //

            iFmtWidth /= 3;
            if (fHScroll = (xposition < ped->rcFmt.left))
            {
                //
                // scroll to the left
                //
                iAmt = ped->rcFmt.left + iFmtWidth;
            }
            else if (fHScroll = (xposition > ped->rcFmt.right))
            {
                //
                // scroll to the right
                //
                iAmt = ped->rcFmt.right - iFmtWidth;
            }

            if (fHScroll)
            {
                EditML_Scroll(ped, FALSE, EM_LINESCROLL, (xposition - iAmt) / ped->aveCharWidth, TRUE);
            }
        }
    }
    return fVScroll;
}


//---------------------------------------------------------------------------//
// 
// EditML_WndProc
// 
// Class procedure for all multi line edit controls.
// Dispatches all messages to the appropriate handlers which are named
// as follows:
//
// EditSL_ (single line) prefixes all single line edit control procedures while
// Edit_   (edit control) prefixes all common handlers.
//
// The EditML_WndProc only handles messages specific to multi line edit
// controls.
//
LRESULT EditML_WndProc(PED ped, UINT message, WPARAM wParam, LPARAM lParam)
{
    HDC         hdc;
    PAINTSTRUCT ps;
    LPRECT      lprc;
    POINT       pt;
    DWORD       windowstyle;
    static INT  scWheelDelta;

    switch (message) 
    {

    case WM_INPUTLANGCHANGE:
        if (ped && ped->fFocus && ped->pLpkEditCallout) 
        {
            INT cxCaret;

            SystemParametersInfo(SPI_GETCARETWIDTH, 0, (LPVOID)&cxCaret, 0);

            HideCaret(ped->hwnd);
            hdc = Edit_GetDC(ped, TRUE);
            DestroyCaret();

            ped->pLpkEditCallout->EditCreateCaret((PED0)ped, hdc, cxCaret, ped->lineHeight, (UINT)lParam);

            EditML_SetCaretPosition(ped, hdc);
            Edit_ReleaseDC(ped, hdc, TRUE);
            ShowCaret(ped->hwnd);
        }
        goto PassToDefaultWindowProc;


    case WM_STYLECHANGED:
        if (ped && ped->pLpkEditCallout) 
        {
            switch (wParam) 
            {

                case GWL_STYLE:
                    Edit_UpdateFormat(ped,
                        ((LPSTYLESTRUCT)lParam)->styleNew,
                        GET_EXSTYLE(ped));

                    return 1L;

                case GWL_EXSTYLE:
                    Edit_UpdateFormat(ped,
                        GET_STYLE(ped),
                        ((LPSTYLESTRUCT)lParam)->styleNew);

                    return 1L;
            }
        }

        goto PassToDefaultWindowProc;

    case WM_CHAR:

        //
        // wParam - the value of the key
        // lParam - modifiers, repeat count etc (not used)
        //
        EditML_Char(ped, (UINT)wParam, 0);

        break;

    case WM_ERASEBKGND:  
    {
        RECT    rc;
        GetClientRect(ped->hwnd, &rc);
#ifdef _USE_DRAW_THEME_TEXT_
        if (!ped->hTheme)
#endif // _USE_DRAW_THEME_TEXT_
        {
            HBRUSH hbr = NULL;
            BOOL   fNeedDelete = FALSE;

            hbr = Edit_GetBrush(ped, (HDC)wParam, &fNeedDelete);
            if (hbr)
            {
                FillRect((HDC)wParam, &rc, hbr);

                if (fNeedDelete)
                {
                    DeleteObject(hbr);
                }
            }

        }
#ifdef _USE_DRAW_THEME_TEXT_
        else
        {
            HRESULT hr;
            INT     iStateId = Edit_GetStateId(ped);
            hr = DrawThemeBackground(ped->hTheme, (HDC)wParam, EP_EDITTEXT, iStateId, &rc, 0);
        }
#endif // _USE_DRAW_THEME_TEXT_
        return TRUE;

    }
    case WM_GETDLGCODE: 
    {
            LONG code = DLGC_WANTCHARS | DLGC_HASSETSEL | DLGC_WANTARROWS | DLGC_WANTALLKEYS;

            //
            // !!! JEFFBOG HACK !!!
            // Only set Dialog Box Flag if GETDLGCODE message is generated by
            // IsDialogMessage -- if so, the lParam will be a pointer to the
            // message structure passed to IsDialogMessage; otherwise, lParam
            // will be NULL. Reason for the HACK alert: the wParam & lParam
            // for GETDLGCODE is still not clearly defined and may end up
            // changing in a way that would throw this off
            //
            if (lParam)
            {
               // Mark ML edit ctrl as in a dialog box
               ped->fInDialogBox = TRUE;
            }

            //
            // If this is a WM_SYSCHAR message generated by the UNDO keystroke
            // we want this message so we can EAT IT in "case WM_SYSCHAR:"
            //
            if (lParam && (((LPMSG)lParam)->message == WM_SYSCHAR) &&
                    ((DWORD)((LPMSG)lParam)->lParam & SYS_ALTERNATE) &&
                    ((WORD)wParam == VK_BACK))
            {
                 code |= DLGC_WANTMESSAGE;
            }

            return code;
        }

    case EM_SCROLL:
        message = WM_VSCROLL;

        //
        // FALL THROUGH
        //

    case WM_HSCROLL:
    case WM_VSCROLL:
        return EditML_Scroll(ped, (message==WM_VSCROLL), LOWORD(wParam), HIWORD(wParam), TRUE);

    case WM_MOUSEWHEEL:
    {
        UINT ucWheelScrollLines;

        //
        // Don't handle zoom and datazoom.
        //
        if (wParam & (MK_SHIFT | MK_CONTROL)) 
        {
            goto PassToDefaultWindowProc;
        }

        scWheelDelta -= (short) HIWORD(wParam);
        windowstyle = GET_STYLE(ped);
        SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0, (LPVOID)&ucWheelScrollLines, 0); 
        if (    abs(scWheelDelta) >= WHEEL_DELTA &&
                ucWheelScrollLines > 0 &&
                (windowstyle & (WS_VSCROLL | WS_HSCROLL))) 
        {
            int     cLineScroll;
            BOOL    fVert;
            int     cPage;

            if (windowstyle & WS_VSCROLL) 
            {
                fVert = TRUE;
                cPage = ped->ichLinesOnScreen;
            } 
            else 
            {
                fVert = FALSE;
                cPage = (ped->rcFmt.right - ped->rcFmt.left) / ped->aveCharWidth;
            }

            //
            // Limit a roll of one (1) WHEEL_DELTA to scroll one (1) page.
            //
            cLineScroll = (int) min(
                    (UINT) (max(1, (cPage - 1))),
                    ucWheelScrollLines);

            cLineScroll *= (scWheelDelta / WHEEL_DELTA);
            UserAssert(cLineScroll != 0);
            scWheelDelta = scWheelDelta % WHEEL_DELTA;
            EditML_Scroll(ped, fVert, EM_LINESCROLL, cLineScroll, TRUE);
        }

        break;

    }
    case WM_KEYDOWN:

        //
        // wParam - virt keycode of the given key
        // lParam - modifiers such as repeat count etc. (not used)
        //
        EditML_KeyDown(ped, (UINT)wParam, 0);
        break;

    case WM_KILLFOCUS:

        //
        // wParam - handle of the window that receives the input focus
        // lParam - not used
        //
        scWheelDelta = 0;
        EditML_KillFocus(ped);
        break;

    case WM_CAPTURECHANGED:
        //
        // wParam -- unused
        // lParam -- hwnd of window gaining capture.
        //
        if (ped->fMouseDown) 
        {
            //
            // We don't change the caret pos here.  If this is happening
            // due to button up, then we'll change the pos in the
            // handler after ReleaseCapture().  Otherwise, just end
            // gracefully because someone else has stolen capture out
            // from under us.
            //

            ped->fMouseDown = FALSE;
            KillTimer(ped->hwnd, IDSYS_SCROLL);
        }

        break;

    case WM_SYSTIMER:

        //
        // This allows us to automatically scroll if the user holds the mouse
        // outside the edit control window. We simulate mouse moves at timer
        // intervals set in MouseMotionHandler.
        //
        if (ped->fMouseDown)
        {
            EditML_MouseMotion(ped, WM_MOUSEMOVE, ped->prevKeys, &ped->ptPrevMouse);
        }

        break;

    case WM_MBUTTONDOWN:
        EnterReaderMode(ped->hwnd);

        break;

    case WM_MOUSEMOVE:
        UserAssert(ped->fMouseDown);

        //
        // FALL THROUGH
        //

    case WM_LBUTTONDBLCLK:
    case WM_LBUTTONDOWN:
    case WM_LBUTTONUP:
        //
        // wParam - contains a value that indicates which virtual keys are down
        // lParam - contains x and y coords of the mouse cursor
        //
        POINTSTOPOINT(pt, lParam);
        EditML_MouseMotion(ped, message, (UINT)wParam, &pt);

        break;

    case WM_CREATE:

        //
        // wParam - handle to window being created
        // lParam - points to a CREATESTRUCT that contains copies of parameters
        // passed to the CreateWindow function.
        //
        return EditML_Create(ped, (LPCREATESTRUCT)lParam);

    case WM_PRINTCLIENT:
        EditML_Paint(ped, (HDC) wParam, NULL);

        break;

    case WM_PAINT:
        //
        // wParam - can be hdc from subclassed paint
        // lParam - not used
        //
        if (wParam) 
        {
            hdc = (HDC)wParam;
            lprc = NULL;
        } 
        else 
        {
            hdc = BeginPaint(ped->hwnd, &ps);
            lprc = &ps.rcPaint;
        }

        if (IsWindowVisible(ped->hwnd))
        {
            EditML_Paint(ped, hdc, lprc);
        }

        if (!wParam)
        {
            EndPaint(ped->hwnd, &ps);
        }

        break;

    case WM_PASTE:

        //
        // wParam - not used
        // lParam - not used
        //
        if (!ped->fReadOnly)
        {
            EditML_PasteText(ped);
        }

        break;

    case WM_SETFOCUS:

        //
        // wParam - handle of window that loses the input focus (may be NULL)
        // lParam - not used
        //
        EditML_SetFocus(ped);

        break;

    case WM_SIZE:

        //
        // wParam - defines the type of resizing fullscreen, sizeiconic,
        //          sizenormal etc.
        // lParam - new width in LOWORD, new height in HIGHWORD of client area
        //
        Edit_Size(ped, NULL, TRUE);

        break;

    case EM_FMTLINES:

        //
        // wParam - indicates disposition of end-of-line chars. If non
        // zero, the chars CR CR LF are placed at the end of a word
        // wrapped line. If wParam is zero, the end of line chars are
        // removed. This is only done when the user gets a handle (via
        // EM_GETHANDLE) to the text. lParam - not used.
        //
        if (wParam)
        {
            EditML_InsertCrCrLf(ped);
        }
        else
        {
            EditML_StripCrCrLf(ped);
        }

        EditML_BuildchLines(ped, 0, 0, FALSE, NULL, NULL);

        return (LONG)(wParam != 0);

    case EM_GETHANDLE:

        //
        // wParam - not used
        // lParam - not used
        //

        //
        // Returns a handle to the edit control's text.
        //

        //
        // Null terminate the string. Note that we are guaranteed to have the
        // memory for the NULL since Edit_InsertText allocates an extra
        // WCHAR for the NULL terminator.
        //

        if (ped->fAnsi)
        {
            *(Edit_Lock(ped) + ped->cch) = 0;
        }
        else
        {
            *((LPWSTR)Edit_Lock(ped) + ped->cch) = 0;
        }

        Edit_Unlock(ped);

        return ((LRESULT)ped->hText);

    case EM_GETLINE:

        //
        // wParam - line number to copy (0 is first line)
        // lParam - buffer to copy text to. First WORD is max # of bytes to
        // copy
        //
        return EditML_GetLine(ped, (ICH)wParam, (ICH)*(WORD UNALIGNED *)lParam, (LPSTR)lParam);

    case EM_LINEFROMCHAR:

        //
        // wParam - Contains the index value for the desired char in the text
        // of the edit control. These are 0 based.
        // lParam - not used
        //
        return (LRESULT)EditML_IchToLine(ped, (ICH)wParam);

    case EM_LINEINDEX:

        //
        // wParam - specifies the desired line number where the number of the
        // first line is 0. If linenumber = 0, the line with the caret is used.
        // lParam - not used.
        // This function return s the number of character positions that occur
        // preceeding the first char in a given line.
        //
        return (LRESULT)EditML_LineIndex(ped, (ICH)wParam);

    case EM_LINELENGTH:

        //
        // wParam - specifies the character index of a character in the
        // specified line, where the first line is 0. If -1, the length
        // of the current line (with the caret) is return ed not including the
        // length of any selected text.
        // lParam - not used
        //
        return (LRESULT)EditML_LineLength(ped, (ICH)wParam);

    case EM_LINESCROLL:

        //
        // wParam - not used
        // lParam - Contains the number of lines and char positions to scroll
        //
        EditML_Scroll(ped, TRUE,  EM_LINESCROLL, (INT)lParam, TRUE);
        EditML_Scroll(ped, FALSE, EM_LINESCROLL, (INT)wParam, TRUE);

        break;

    case EM_REPLACESEL:

        //
        // wParam - flag for 4.0+ apps saying whether to clear undo
        // lParam - Points to a null terminated replacement text.
        //
        EditML_ReplaceSel(ped, (LPSTR)lParam);

        if (!ped->f40Compat || !wParam)
        {
            Edit_EmptyUndo(Pundo(ped));
        }

        break;

    case EM_SETHANDLE:

        //
        // wParam - contains a handle to the text buffer
        // lParam - not used
        //
        EditML_SetHandle(ped, (HANDLE)wParam);

        break;

    case EM_SETRECT:
    case EM_SETRECTNP:

        //
        // wParamLo --    not used
        // lParam --    LPRECT with new formatting area
        //
        Edit_Size(ped, (LPRECT) lParam, (message != EM_SETRECTNP));

        break;

    case EM_SETSEL:

        //
        // wParam - Under 3.1, specifies if we should scroll caret into
        // view or not. 0 == scroll into view. 1 == don't scroll
        // lParam - starting pos in lowword ending pos in high word
        // 
        // Under Win32, wParam is the starting pos, lParam is the
        // ending pos, and the caret is not scrolled into view.
        // The message EM_SCROLLCARET forces the caret to be scrolled
        // into view.
        //
        EditML_SetSelection(ped, TRUE, (ICH)wParam, (ICH)lParam);

        break;

    case EM_SCROLLCARET:

        //
        // Scroll caret into view
        //
        EditML_EnsureCaretVisible(ped);
        break;

    case EM_GETFIRSTVISIBLELINE:

        //
        // Returns the first visible line for multiline edit controls.
        //
        return (LONG)ped->ichScreenStart;

    case WM_SYSKEYDOWN:
        if (((WORD)wParam == VK_BACK) && ((DWORD)lParam & SYS_ALTERNATE)) 
        {
            SendMessage(ped->hwnd, EM_UNDO, 0, 0L);
            break;
        }

        goto PassToDefaultWindowProc;

    case WM_UNDO:
    case EM_UNDO:
        return EditML_Undo(ped);

    case EM_SETTABSTOPS:

        //
        // This sets the tab stop positions for multiline edit controls.
        // wParam - Number of tab stops
        // lParam - Far ptr to a UINT array containing the Tab stop positions
        //
        return EditML_SetTabStops(ped, (int)wParam, (LPINT)lParam);

    case EM_POSFROMCHAR:
        //
        // wParam --    char index in text
        // lParam --    not used
        // This function returns the (x,y) position of the character
        //
    case EM_CHARFROMPOS:
        //
        // wParam --    unused
        // lParam --    pt in client coordinates
        // This function returns
        //      LOWORD: the position of the closest character
        //              to the passed in point.  Beware of
        //              points not actually in the edit client...
        //      HIWORD: the index of the line the char is on
        //
        {
            LONG  xyPos;
            LONG  line;

            hdc = Edit_GetDC(ped, TRUE);

            if (message == EM_POSFROMCHAR) 
            {
                EditML_IchToXYPos(ped, hdc, (ICH)wParam, FALSE, &pt);
                xyPos = MAKELONG(pt.x, pt.y);
            } 
            else 
            {
                POINTSTOPOINT(pt, lParam);
                xyPos = EditML_MouseToIch(ped, hdc, &pt, &line);
                xyPos = MAKELONG(xyPos, line);
            }

            Edit_ReleaseDC(ped, hdc, TRUE);

            return (LRESULT)xyPos;
        }

    case WM_SETREDRAW:
        DefWindowProc(ped->hwnd, message, wParam, lParam);
        if (wParam) 
        {
            //
            // Backwards compatability hack needed so that winraid's edit
            // controls work fine.
            //
            RedrawWindow(ped->hwnd, NULL, NULL, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME);
        }

        break;

    default:
PassToDefaultWindowProc:
        return DefWindowProc(ped->hwnd, message, wParam, lParam);
    }

    return TRUE;
}


//---------------------------------------------------------------------------//
//
// EditML_DrawText AorW
// 
// This function draws all the characters between ichStart and ichEnd for
// the given Multiline Edit Control.
//
// This function divides the block of text between ichStart and ichEnd
// into lines and each line into strips of text based on the selection
// attributes. It calls Edit_TabTheTextOut() to draw each strip.
// This takes care of the Negative A anc C widths of the current font, if
// it has any, on either side of each strip of text.
//
// NOTE: If the language pack is loaded the text is not divided into strips,
// nor is selection highlighting performed here. Whole lines are passed
// to the language pack to display with tab expansion and selection
// highlighting. (Since the language pack supports scripts with complex
// character re-ordering rules, only it can do this).
//
VOID EditML_DrawText(PED ped, HDC hdc, ICH ichStart, ICH ichEnd, BOOL fSelChange)
{
    DWORD   textColorSave;
    DWORD   bkColorSave;
    PSTR    pText;
    UINT    wCurLine;
    UINT    wEndLine;
    INT     xOffset;
    ICH     LengthToDraw;
    ICH     CurStripLength;
    ICH     ichAttrib, ichNewStart;
    ICH     ExtraLengthForNegA;
    ICH     ichT;
    INT     iRemainingLengthInLine;
    INT     xStPos, xClipStPos, xClipEndPos, yPos;

    BOOL    fFirstLineOfBlock   = TRUE;
    BOOL    fDrawEndOfLineStrip = FALSE;
    BOOL    fDrawOnSameLine     = FALSE;
    BOOL    fSelected           = FALSE;
    BOOL    fLineBegins         = FALSE;

    STRIPINFO   NegCInfo;
    POINT   pt;
    HBRUSH  hbr = NULL;
    BOOL    fNeedDelete = FALSE;
 
    //
    // Just return if nothing to draw
    //
    if (!ped->ichLinesOnScreen)
    {
        return;
    }

    hbr = Edit_GetBrush(ped, hdc, &fNeedDelete);
    if (hbr && fNeedDelete)
    {
        DeleteObject(hbr);
    }

    //
    // Adjust the value of ichStart such that we need to draw only those lines
    // visible on the screen.
    //
    if ((UINT)ichStart < (UINT)ped->chLines[ped->ichScreenStart]) 
    {
        ichStart = ped->chLines[ped->ichScreenStart];
        if (ichStart > ichEnd)
        {
            return;
        }
    }

    //
    // Adjust the value of ichEnd such that we need to draw only those lines
    // visible on the screen.
    //
    wCurLine = min(ped->ichScreenStart+ped->ichLinesOnScreen,ped->cLines-1);
    ichT = ped->chLines[wCurLine] + EditML_Line(ped, wCurLine);
    ichEnd = min(ichEnd, ichT);

    wCurLine = EditML_IchToLine(ped, ichStart);  // Starting line.
    wEndLine = EditML_IchToLine(ped, ichEnd);    // Ending line.

    UserAssert(ped->chLines[wCurLine] <= ped->cch + 1);
    UserAssert(ped->chLines[wEndLine] <= ped->cch + 1);

    if (fSelChange && (GetBkMode(hdc) != OPAQUE))
    {
        //
        // if changing selection on a transparent edit control, just
        // draw those lines from scratch
        //
        RECT rcStrip;
        CopyRect(&rcStrip, &ped->rcFmt);
        rcStrip.left -= ped->wLeftMargin;
        if (ped->pLpkEditCallout) 
        {
            rcStrip.right += ped->wRightMargin;
        }

        rcStrip.top += (wCurLine - ped->ichScreenStart) * ped->lineHeight;
        rcStrip.bottom = rcStrip.top + ((wEndLine - wCurLine) + 1) * ped->lineHeight;
        InvalidateRect(ped->hwnd, &rcStrip, TRUE);
        return;
    }

    //
    // If it is either centered or right-justified, then draw the whole lines.
    // Also draw whole lines if the language pack is handling line layout.
    //
    if ((ped->format != ES_LEFT) || (ped->pLpkEditCallout)) 
    {
        ichStart = ped->chLines[wCurLine];
        ichEnd = ped->chLines[wEndLine] + EditML_Line(ped, wEndLine);
    }

    pText = Edit_Lock(ped);

    HideCaret(ped->hwnd);

    //
    // If ichStart stays on Second byte of DBCS, we have to
    // adjust it. LiZ -- 5/5/93
    //
    if (ped->fAnsi && ped->fDBCS) 
    {
        ichStart = Edit_AdjustIch( ped, pText, ichStart );
    }
    UserAssert(ichStart <= ped->cch);
    UserAssert(ichEnd <= ped->cch);

    while (ichStart <= ichEnd) 
    {
        //
        // Pass whole lines to the language pack to display with selection
        // marking and tab expansion.
        //
        if (ped->pLpkEditCallout) 
        {
            ped->pLpkEditCallout->EditDrawText(
                (PED0)ped, hdc, pText + ped->cbChar*ichStart,
                EditML_Line(ped, wCurLine),
                (INT)ped->ichMinSel - (INT)ichStart, (INT)ped->ichMaxSel - (INT)ichStart,
                EditML_IchToYPos(ped, ichStart, FALSE));
        } 
        else 
        {
        
            //
            // xStPos:      The starting Position where the string must be drawn.
            // xClipStPos:  The starting position for the clipping rect for the block.
            // xClipEndPos: The ending position for the clipping rect for the block.
            //

            //
            // Calculate the xyPos of starting point of the block.
            //
            EditML_IchToXYPos(ped, hdc, ichStart, FALSE, &pt);
            xClipStPos = xStPos = pt.x;
            yPos = pt.y;

            //
            // The attributes of the block is the same as that of ichStart.
            //
            ichAttrib = ichStart;

            //
            // If the current font has some negative C widths and if this is the
            // begining of a block, we must start drawing some characters before the
            // block to account for the negative C widths of the strip before the
            // current strip; In this case, reset ichStart and xStPos.
            //

            if (fFirstLineOfBlock && ped->wMaxNegC) 
            {
                fFirstLineOfBlock = FALSE;
                ichNewStart = max(((int)(ichStart - ped->wMaxNegCcharPos)), ((int)ped->chLines[wCurLine]));

                //
                // If ichStart needs to be changed, then change xStPos also accordingly.
                //
                if (ichNewStart != ichStart) 
                {
                    if (ped->fAnsi && ped->fDBCS) 
                    {
                        //
                        // Adjust DBCS alignment...
                        //
                        ichNewStart = Edit_AdjustIchNext( ped, pText, ichNewStart );
                    }
                    EditML_IchToXYPos(ped, hdc, ichStart = ichNewStart, FALSE, &pt);
                    xStPos = pt.x;
                }
            }

            //
            // Calc the number of characters remaining to be drawn in the current line.
            //
            iRemainingLengthInLine = EditML_Line(ped, wCurLine) -
                                    (ichStart - ped->chLines[wCurLine]);

            //
            // If this is the last line of a block, we may not have to draw all the
            // remaining lines; We must draw only upto ichEnd.
            //
            if (wCurLine == wEndLine)
            {
                LengthToDraw = ichEnd - ichStart;
            }
            else
            {
                LengthToDraw = iRemainingLengthInLine;
            }

            //
            // Find out how many pixels we indent the line for non-left-justified
            // formats
            //
            if (ped->format != ES_LEFT)
            {
                xOffset = EditML_CalcXOffset(ped, hdc, wCurLine);
            }
            else
            {
                xOffset = -((int)(ped->xOffset));
            }

            //
            // Check if this is the begining of a line.
            //
            if (ichAttrib == ped->chLines[wCurLine]) 
            {
                fLineBegins = TRUE;
                xClipStPos = ped->rcFmt.left - ped->wLeftMargin;
            }

            //
            // The following loop divides this 'wCurLine' into strips based on the
            // selection attributes and draw them strip by strip.
            //
            do  
            {
                //
                // If ichStart is pointing at CRLF or CRCRLF, then iRemainingLength
                // could have become negative because MLLine does not include
                // CR and LF at the end of a line.
                //
                if (iRemainingLengthInLine < 0)  // If Current line is completed,
                {
                    break;                   // go on to the next line.
                }

                //
                // Check if a part of the block is selected and if we need to
                // show it with a different attribute.
                //
                if (!(ped->ichMinSel == ped->ichMaxSel ||
                            ichAttrib >= ped->ichMaxSel ||
                            ichEnd   <  ped->ichMinSel ||
                            (!ped->fNoHideSel && !ped->fFocus))) 
                {
                    //
                    // OK! There is a selection somewhere in this block!
                    // Check if this strip has selection attribute.
                    //
                    if (ichAttrib < ped->ichMinSel) 
                    {
                        fSelected = FALSE;  // This strip is not selected

                        // Calculate the length of this strip with normal attribute.
                        CurStripLength = min(ichStart+LengthToDraw, ped->ichMinSel)-ichStart;
                        fLineBegins = FALSE;
                    } 
                    else 
                    {
                        //
                        // The current strip has the selection attribute.
                        //
                        if (fLineBegins) // Is it the first part of a line?
                        {  
                            //
                            // Then, draw the left margin area with normal attribute.
                            //
                            fSelected = FALSE;
                            CurStripLength = 0;
                            xClipStPos = ped->rcFmt.left - ped->wLeftMargin;
                            fLineBegins = FALSE;
                        } 
                        else 
                        {
                            //
                            // Else, draw the strip with selection attribute.
                            //
                            fSelected = TRUE;
                            CurStripLength = min(ichStart+LengthToDraw, ped->ichMaxSel)-ichStart;

                            //
                            // Select in the highlight colors.
                            //
                            bkColorSave = SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
                            if (!ped->fDisabled)
                            {
                                textColorSave = SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
                            }
                        }
                    }
                } 
                else 
                {
                    //
                    // The whole strip has no selection attributes.
                    //
                    CurStripLength = LengthToDraw;
                }

                //
                // Other than the current strip, do we still have anything
                // left to be drawn in the current line?
                //
                fDrawOnSameLine = (LengthToDraw != CurStripLength);

                //
                // When we draw this strip, we need to draw some more characters
                // beyond the end of this strip to account for the negative A
                // widths of the characters that follow this strip.
                //
                ExtraLengthForNegA = min(iRemainingLengthInLine-CurStripLength, ped->wMaxNegAcharPos);

                //
                // The blank strip at the end of the line needs to be drawn with
                // normal attribute irrespective of whether the line has selection
                // attribute or not. Hence, if the last strip of the line has selection
                // attribute, then this blank strip needs to be drawn separately.
                // Else, we can draw the blank strip along with the last strip.
                //

                //
                // Is this the last strip of the current line?
                //
                if (iRemainingLengthInLine == (int)CurStripLength) 
                {
                    if (fSelected)  // Does this strip have selection attribute?
                    { 
                        //
                        // Then we need to draw the end of line strip separately.
                        //
                        fDrawEndOfLineStrip = TRUE;  // Draw the end of line strip.
                        EditML_IchToXYPos(ped, hdc, ichStart+CurStripLength, TRUE, &pt);
                        xClipEndPos = pt.x;
                    } 
                    else 
                    {
                        //
                        // Set the xClipEndPos to a big value sothat the blank
                        // strip will be drawn automatically when the last strip
                        // is drawn.
                        //
                        xClipEndPos = MAXCLIPENDPOS;
                    }
                } 
                else 
                {
                    //
                    // This is not the last strip of this line; So, set the ending
                    // clip position accurately.
                    //
                    EditML_IchToXYPos(ped, hdc, ichStart+CurStripLength, FALSE, &pt);
                    xClipEndPos = pt.x;
                }

                //
                // Draw the current strip starting from xStPos, clipped to the area
                // between xClipStPos and xClipEndPos. Obtain "NegCInfo" and use it
                // in drawing the next strip.
                //
                Edit_TabTheTextOut(hdc, xClipStPos, xClipEndPos,
                        xStPos, yPos, (LPSTR)(pText+ichStart*ped->cbChar),
                    CurStripLength+ExtraLengthForNegA, ichStart, ped,
                    ped->rcFmt.left+xOffset, fSelected ? ECT_SELECTED : ECT_NORMAL, &NegCInfo);

                if (fSelected) 
                {
                    //
                    // If this strip was selected, then the next strip won't have
                    // selection attribute
                    //
                    fSelected = FALSE;
                    SetBkColor(hdc, bkColorSave);
                    if (!ped->fDisabled)
                    {
                        SetTextColor(hdc, textColorSave);
                    }
                }

                //
                // Do we have one more strip to draw on the current line?
                //
                if (fDrawOnSameLine || fDrawEndOfLineStrip) 
                {
                    int  iLastDrawnLength;

                    //
                    // Next strip's attribute is decided based on the char at ichAttrib
                    //
                    ichAttrib = ichStart + CurStripLength;

                    //
                    // When drawing the next strip, start at a few chars before
                    // the actual start to account for the Neg 'C' of the strip
                    // just drawn.
                    //
                    iLastDrawnLength = CurStripLength +ExtraLengthForNegA - NegCInfo.nCount;
                    //
                    // Adjust DBCS alignment...
                    //
                    if (ped->fAnsi && ped->fDBCS) 
                    {
                        ichNewStart = Edit_AdjustIch(ped,pText,ichStart+iLastDrawnLength);
                        iLastDrawnLength = ichNewStart - ichStart;
                        ichStart = ichNewStart;
                    } 
                    else 
                    {
                        ichStart += iLastDrawnLength;
                    }
                    LengthToDraw -= iLastDrawnLength;
                    iRemainingLengthInLine -= iLastDrawnLength;

                    //
                    // The start of clip rect for the next strip.
                    //
                    xStPos = NegCInfo.XStartPos;
                    xClipStPos = xClipEndPos;
                }

                //
                // Draw the blank strip at the end of line seperately, if required.
                //
                if (fDrawEndOfLineStrip) 
                {
                    Edit_TabTheTextOut(hdc, xClipStPos, MAXCLIPENDPOS, xStPos, yPos,
                        (LPSTR)(pText+ichStart*ped->cbChar), LengthToDraw, ichStart,
                        ped, ped->rcFmt.left+xOffset, ECT_NORMAL, &NegCInfo);

                    fDrawEndOfLineStrip = FALSE;
                }
            }
            while(fDrawOnSameLine);   // do while loop ends here.
        }

        // Let us move on to the next line of this block to be drawn.
        wCurLine++;
        if (ped->cLines > wCurLine)
        {
            ichStart = ped->chLines[wCurLine];
        }
        else
        {
            ichStart = ichEnd+1;   // We have reached the end of the text.
        }
    }  // while loop ends here

    Edit_Unlock(ped);

    ShowCaret(ped->hwnd);
    EditML_SetCaretPosition(ped, hdc);
}


//---------------------------------------------------------------------------//
//
// Multi-Line Support Routines called Rarely


//---------------------------------------------------------------------------//
//
// EditML_InsertCrCrLf AorW
//
// 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.
//
BOOL EditML_InsertCrCrLf(PED ped)
{
    ICH dch;
    ICH li;
    ICH lineSize;
    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 * ped->cLines;

    if (!LocalReAlloc(ped->hText, (ped->cch + dch) * ped->cbChar, 0)) 
    {
        Edit_NotifyParent(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 = Edit_Lock(ped);
    pchText += dch * ped->cbChar;

    //
    // We will use dch to keep track of how many chars we add to the text
    //
    dch = 0;

    //
    // Copy the text up dch bytes to pchText. This will shift all indices in
    // ped->chLines up by dch bytes.
    //
    memmove(pchText, pchTextNew, ped->cch * ped->cbChar);

    //
    // Now copy chars from pchText down to pchTextNew and insert CRCRLF at soft
    // line breaks.
    //
    if (ped->fAnsi) 
    {
        for (li = 0; li < ped->cLines - 1; li++) 
        {
            lineSize = ped->chLines[li + 1] - ped->chLines[li];
            memmove(pchTextNew, pchText, 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 (*(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...
        //
        memmove(pchTextNew, pchText, ped->cch - ped->chLines[ped->cLines - 1]);
    } 
    else 
    {
        LPWSTR pwchTextNew = (LPWSTR)pchTextNew;

        for (li = 0; li < ped->cLines - 1; li++) 
        {
            lineSize = ped->chLines[li + 1] - ped->chLines[li];
            memmove(pwchTextNew, pchText, lineSize * sizeof(WCHAR));
            pwchTextNew += lineSize;
            pchText += lineSize * sizeof(WCHAR);

            //
            // 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 (*(pwchTextNew - 1) != 0x0A) 
            {
                *pwchTextNew++ = 0x0D;
                *pwchTextNew++ = 0x0D;
                *pwchTextNew++ = 0x0A;
                dch += 3;
            }
        }

        //
        // Now move the last line up. It won't have any line breaks in it...
        //
        memmove(pwchTextNew, pchText,
            (ped->cch - ped->chLines[ped->cLines - 1]) * sizeof(WCHAR));
    }

    Edit_Unlock(ped);

    if (dch) 
    {
        //
        // Update number of characters in text handle
        //
        ped->cch += dch;

        //
        // So that the next time we do anything with the text, we can strip the
        // CRCRLFs
        //
        ped->fStripCRCRLF = TRUE;

        return TRUE;
    }

    return FALSE;
}


//---------------------------------------------------------------------------//
//
// EditML_StripCrCrLf AorW
//
// 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.
//
void EditML_StripCrCrLf(PED ped)
{
    if (ped->cch) 
    {
        if (ped->fAnsi) 
        {
            unsigned char *pchSrc;
            unsigned char *pchDst;
            unsigned char *pchLast;

            pchSrc = pchDst = Edit_Lock(ped);
            pchLast = pchSrc + ped->cch;
            while (pchSrc < pchLast) 
            {
                if (   (pchSrc[0] == 0x0D)
                    && (pchSrc[1] == 0x0D)
                    && (pchSrc[2] == 0x0A)
                ) 
                {
                    pchSrc += 3;
                    ped->cch -= 3;
                } 
                else 
                {
                    *pchDst++ = *pchSrc++;
                }
            }
        }   
        else 
        {
            LPWSTR pwchSrc;
            LPWSTR pwchDst;
            LPWSTR pwchLast;

            pwchSrc = pwchDst = (LPWSTR)Edit_Lock(ped);
            pwchLast = pwchSrc + ped->cch;
            while (pwchSrc < pwchLast) 
            {
                if (   (pwchSrc[0] == 0x0D)
                    && (pwchSrc[1] == 0x0D)
                    && (pwchSrc[2] == 0x0A)
                ) 
                {
                    pwchSrc += 3;
                    ped->cch -= 3;
                } 
                else 
                {
                    *pwchDst++ = *pwchSrc++;
                }
            }
        }

        Edit_Unlock(ped);

        //
        // Make sure we don't have any values past the last character
        //
        if (ped->ichCaret > ped->cch)
        {
            ped->ichCaret  = ped->cch;
        }

        if (ped->ichMinSel > ped->cch)
        {
            ped->ichMinSel = ped->cch;
        }

        if (ped->ichMaxSel > ped->cch)
        {
            ped->ichMaxSel = ped->cch;
        }
    }
}


//---------------------------------------------------------------------------//
//
// EditML_SetHandle AorW
//
// Sets the ped to contain the given handle.
//
void EditML_SetHandle(PED ped, HANDLE hNewText)
{
    ICH newCch;

    ped->cch = ped->cchAlloc =
            (ICH)LocalSize(ped->hText = hNewText) / ped->cbChar;
    ped->fEncoded = FALSE;

    if (ped->cch) 
    {
        //
        // We have to do it this way in case the app gives us a zero size handle
        //
        if (ped->fAnsi)
        {
            ped->cch = strlen(Edit_Lock(ped));
        }
        else
        {
            ped->cch = wcslen((LPWSTR)Edit_Lock(ped));
        }

        Edit_Unlock(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*ped->cbChar, 0))
    {
        ped->cchAlloc = newCch;
    }

    Edit_ResetTextInfo(ped);
}


//---------------------------------------------------------------------------//
//
// EditML_GetLine AorW
//
// Copies maxCchToCopy bytes of line lineNumber to the buffer
// lpBuffer. The string is not zero terminated.
// 
// Returns number of characters copied
//
LONG EditML_GetLine(PED ped, ICH lineNumber, ICH maxCchToCopy, LPSTR lpBuffer)
{
    PSTR pText;
    ICH cchLen;

    if (lineNumber > ped->cLines - 1) 
    {
        TraceMsg(TF_STANDARD,
                "Edit: Invalid parameter \"lineNumber\" (%ld) to EditML_GetLine",
                lineNumber);

        return 0L;
    }

    cchLen = EditML_Line(ped, lineNumber);
    maxCchToCopy = min(cchLen, maxCchToCopy);

    if (maxCchToCopy) 
    {
        pText = Edit_Lock(ped) +
                ped->chLines[lineNumber] * ped->cbChar;
        memmove(lpBuffer, pText, maxCchToCopy*ped->cbChar);
        Edit_Unlock(ped);
    }

    return maxCchToCopy;
}


//---------------------------------------------------------------------------//
//
// EditML_LineIndex AorW
//
// This function return s the number of character positions that occur
// preceeding the first char in a given line.
//
ICH EditML_LineIndex( PED ped, ICH iLine)
{
    if (iLine == -1)
    {
        iLine = ped->iCaretLine;
    }

    if (iLine < ped->cLines) 
    {
        return ped->chLines[iLine];
    } 
    else 
    {
        TraceMsg(TF_STANDARD,
                "Edit: Invalid parameter \"iLine\" (%ld) to EditML_LineIndex",
                iLine);

        return (ICH)-1;
    }
}


//---------------------------------------------------------------------------//
//
// EditML_LineLength AorW
//
// 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 EditML_LineLength(PED ped, ICH ich)
{
    ICH il1, il2;
    ICH temp;

    if (ich != 0xFFFFFFFF)
    {
        return (EditML_Line(ped, EditML_IchToLine(ped, ich)));
    }

    //
    // Find length of lines corresponding to current selection
    //
    il1 = EditML_IchToLine(ped, ped->ichMinSel);
    il2 = EditML_IchToLine(ped, ped->ichMaxSel);
    if (il1 == il2)
    {
        return (EditML_Line(ped, il1) - (ped->ichMaxSel - ped->ichMinSel));
    }

    temp = ped->ichMinSel - ped->chLines[il1];
    temp += EditML_Line(ped, il2);
    temp -= (ped->ichMaxSel - ped->chLines[il2]);

    return temp;
}


//---------------------------------------------------------------------------//
// 
// EditML_SetSelection AorW
//
// Sets the selection to the points given and puts the cursor at
// ichMaxSel.
//
VOID EditML_SetSelection(PED ped, BOOL fDoNotScrollCaret, ICH ichMinSel, ICH ichMaxSel)
{
    HDC hdc;

    if (ichMinSel == 0xFFFFFFFF) 
    {
        //
        // 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 = min(ped->cch, ichMinSel);
    ichMaxSel = min(ped->cch, ichMaxSel);

#ifdef FE_SB // EditML_SetSelectionHander()
    //
    // To avoid position to half of DBCS, check and ajust position if necessary
    //
    // We check ped->fDBCS and ped->fAnsi though Edit_AdjustIch checks these bits
    // at first. We're worrying about the overhead of Edit_Lock and Edit_Unlock.
    //
    if ( ped->fDBCS && ped->fAnsi ) 
    {
        PSTR pText;

        pText = Edit_Lock(ped);

        ichMinSel = Edit_AdjustIch( ped, pText, ichMinSel );
        ichMaxSel = Edit_AdjustIch( ped, pText, ichMaxSel );

        Edit_Unlock(ped);
    }
#endif // FE_SB

    //
    // Set the caret's position to be at ichMaxSel.
    //
    ped->ichCaret = ichMaxSel;
    ped->iCaretLine = EditML_IchToLine(ped, ped->ichCaret);

    hdc = Edit_GetDC(ped, FALSE);
    EditML_ChangeSelection(ped, hdc, ichMinSel, ichMaxSel);

    EditML_SetCaretPosition(ped, hdc);
    Edit_ReleaseDC(ped, hdc, FALSE);

#ifdef FE_SB // EditML_SetSelectionHander()
    if (!fDoNotScrollCaret)
    {
        EditML_EnsureCaretVisible(ped);
    }

    //
    // #ifdef KOREA is history, with FE_SB (FarEast Single Binary).
    //
#else
#ifdef KOREA
    //
    // Extra parameter specified interim character mode
    //
    EditML_EnsureCaretVisible(ped,NULL);
#else
    if (!fDoNotScrollCaret)
    {
        EditML_EnsureCaretVisible(ped);
    }
#endif
#endif // FE_SB

}


//---------------------------------------------------------------------------//
//
// EditML_SetTabStops AorW
//
// 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 EditML_SetTabStops(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
            //
            pTabStops = (LPINT)UserLocalAlloc(HEAP_ZERO_MEMORY, (nTabPos + 1) * sizeof(int));
            if (!pTabStops) 
            {
                return FALSE;
            }
        } 
        else 
        {
            //
            // No stops then and no stops now!
            //
            return TRUE;
        }
    } 
    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
                //
                pTabStops = (LPINT)UserLocalReAlloc(ped->pTabStops, (nTabPos + 1) * sizeof(int), 0);
                if (!pTabStops)
                {
                    return FALSE;
                }
            } 
            else 
            {
                pTabStops = ped->pTabStops;
            }
        } 
        else 
        {
            //
            // Caller wants to remove all the tab stops; So, release
            //
            if (!UserLocalFree(ped->pTabStops))
            {
                return FALSE;
            }

            ped->pTabStops = NULL;

            goto RedrawAndReturn;
        }
    }

    //
    // Copy the new tab stops onto the tab stop array after converting the
    // dialog co-ordinates into the pixel co-ordinates
    //
    ped->pTabStops = pTabStops;

    //
    // First element contains the count
    //
    *pTabStops++ = nTabPos;
    while (nTabPos--) 
    {
        //
        // aveCharWidth must be used instead of cxSysCharWidth.
        // Fix for Bug #3871 --SANKAR-- 03/14/91
        //
        *pTabStops++ = MultDiv(*lpTabStops++, ped->aveCharWidth, 4);
    }

RedrawAndReturn:
    //
    // Because the tabstops have changed, we need to recompute the
    // maxPixelWidth. Otherwise, horizontal scrolls will have problems.
    // Fix for Bug #6042 - 3/15/94
    //
    EditML_BuildchLines(ped, 0, 0, FALSE, NULL, NULL);

    //
    // Caret may have changed line by the line recalc above.
    //
    EditML_UpdateiCaretLine(ped);

    EditML_EnsureCaretVisible(ped);

    //
    // Also, we need to redraw the whole window.
    //
    InvalidateRect(ped->hwnd, NULL, TRUE);

    return TRUE;
}

//---------------------------------------------------------------------------//
//
// EditML_Undo AorW
// 
// Handles Undo for multiline edit controls.
//
BOOL EditML_Undo(PED ped)
{
    HANDLE hDeletedText = ped->hDeletedText;
    BOOL fDelete = (BOOL)(ped->undoType & UNDO_DELETE);
    ICH cchDeleted = ped->cchDeleted;
    ICH ichDeleted = ped->ichDeleted;

    if (ped->undoType == UNDO_NONE) 
    {
        //
        // No undo...
        //
        return FALSE;
    }

    ped->hDeletedText = NULL;
    ped->cchDeleted = 0;
    ped->ichDeleted = (ICH)-1;
    ped->undoType &= ~UNDO_DELETE;

    if (ped->undoType == UNDO_INSERT) 
    {
        ped->undoType = UNDO_NONE;

        //
        // Set the selection to the inserted text
        //
        EditML_SetSelection(ped, FALSE, ped->ichInsStart, ped->ichInsEnd);
        ped->ichInsStart = ped->ichInsEnd = (ICH)-1;

        //
        // Now send a backspace to delete and save it in the undo buffer...
        //
        SendMessage(ped->hwnd, WM_CHAR, (WPARAM)VK_BACK, 0L);
    }

    if (fDelete) 
    {
        //
        // Insert deleted chars
        //

        //
        // Set the selection to the inserted text
        //
        EditML_SetSelection(ped, FALSE, ichDeleted, ichDeleted);
        EditML_InsertText(ped, hDeletedText, cchDeleted, FALSE);

        GlobalFree(hDeletedText);
        EditML_SetSelection(ped, FALSE, ichDeleted, ichDeleted + cchDeleted);
    }

    return TRUE;
}


//---------------------------------------------------------------------------//
// 
// EditML_Create AorW
// 
// Creates the edit control for the window hwnd by allocating memory
// as required from the application's heap. Notifies parent if no memory
// error (after cleaning up if needed). Returns TRUE if no error else return s
// -1.
//
LONG EditML_Create(PED ped, LPCREATESTRUCT lpCreateStruct)
{
    LONG windowStyle;
    LPWSTR lpszName;

    //
    // Get values from the window instance data structure and put them in the
    // ped so that we can access them easier
    //
    windowStyle = GET_STYLE(ped);

    //
    // Do the standard creation stuff
    //
    if (!Edit_Create(ped, windowStyle)) 
    {
        return -1;
    }

    //
    // Allocate line start array in local heap and lock it down
    //
    ped->chLines = (LPICH)LocalAlloc(LPTR, 2 * sizeof(int));
    if (ped->chLines == NULL) 
    {
        return -1;
    }

    //
    // Call it one line of text...
    //
    ped->cLines = 1;

    //
    // If app wants WS_VSCROLL or WS_HSCROLL, it automatically gets AutoVScroll
    // or AutoHScroll.
    //
    if ((windowStyle & ES_AUTOVSCROLL) || (windowStyle & WS_VSCROLL)) 
    {
        ped->fAutoVScroll = 1;
    }

    if (ped->format != ES_LEFT)
    {
        //
        // If user wants right or center justified text, then we turn off
        // AUTOHSCROLL and WS_HSCROLL since non-left styles don't make sense
        // otherwise.
        //
        windowStyle &= ~WS_HSCROLL;
        ClearWindowState(ped->hwnd, WS_HSCROLL);
        ped->fAutoHScroll = FALSE;
    }
    else if (windowStyle & WS_HSCROLL) 
    {
        ped->fAutoHScroll = TRUE;
    }

    ped->fWrap = (!ped->fAutoHScroll && !(windowStyle & WS_HSCROLL));

    //
    // Max # chars we will allow user to enter
    //
    ped->cchTextMax = MAXTEXT;

    //
    // Set the default font to be the system font.
    //
    if ( !Edit_SetFont(ped, NULL, FALSE) )
    {

        // If setting the font fails, our textmetrics can potentially be left 
        // unitialized. Fail to create the control.
        return -1;
    }

    //
    // Set the window text if needed and notify parent if not enough memory to
    // set the initial text.
    //
#if 0
    if ((ULONG_PTR)lpCreateStruct->lpszName > gHighestUserAddress)
    {
        lpszName = REBASEPTR(ped->pwnd, (PVOID)lpCreateStruct->lpszName);
    }
    else
#endif
    {
        lpszName = (LPWSTR)lpCreateStruct->lpszName;
    }

    if (!Edit_SetEditText(ped, (LPSTR)lpszName))
    {
        return -1;
    }

    return TRUE;
}