windows-xp/Source/XPSP1/NT/base/ntsetup/win95upg/w95upg/ui/textview.c

/*++

Copyright (c) 1997 Microsoft Corporation

Module Name:

    textview.c

Abstract:

    The code in this module implements a simple text view control
    that supports a few HTML-style tags.  The caller sets the control
    font with WM_SETFONT, then adds text line-by-line by sending
    WMX_ADDLINE messages, and finally sends a WMX_GOTO to jump to
    a specific bookmark.

    WMX_ADDLINE

        wParam: Specifies a pointer to a LINEATTRIBS struct, or
                NULL if the last line's attributes are to be
                used.  (If no lines exist and wParam is NULL,
                default attributes are used.)

        lParam: Specifes a pointer to the text to add.

        Return Value: The number of bytes of the lParam string
                      that are visible in the control.


        The text can contain the following HTML-style tags:

        <B>                 - Turns on BOLD
        </B>                - Turns off BOLD
        <U>                 - Turns on UNDERLINE
        </U>                - Turns off UNDERLINE
        <UL>                - Indents text
        </UL>               - Unindents text
        <HR>                - A separator line
        <A name=bookmark>   - Specifies a bookmark (see WMX_GOTO)
        <BR>                - Adds a line break


        Line-feed and carriage-return characters are interpreted as <BR>.

    WMX_GOTO

        wParam: Unused

        lParam: Specifies a pointer to the string specifing the bookmark
                to jump to.

        Return Value: Always zero.

Author:

    Jim Schmidt (jimschm) 28-Oct-1997

Revision History:

    jimschm     23-Sep-1998 IDC_HAND collision fix (now IDC_OUR_HAND)

--*/

#include "pch.h"
#include "uip.h"

#include <shellapi.h>


UINT g_HangingIndentPixels;
PCTSTR g_HangingIndentString = TEXT("    ");
UINT g_FarEastFudgeFactor;
extern BOOL g_Terminated;

#define COMMAND_BOLD            1
#define COMMAND_BOLD_END        2
#define COMMAND_UNDERLINE       3
#define COMMAND_UNDERLINE_END   4
#define COMMAND_HORZ_RULE       5
#define COMMAND_ANCHOR          6
#define COMMAND_ANCHOR_END      7
#define COMMAND_INDENT          8
#define COMMAND_UNINDENT        9
#define COMMAND_LIST_ITEM       10
#define COMMAND_LIST_ITEM_END   11
#define COMMAND_LINE_BREAK      12
#define COMMAND_WHITESPACE      13
#define COMMAND_PARAGRAPH       14
#define COMMAND_ESCAPED_CHAR    15


typedef struct {
    BYTE Command;
    PCTSTR Text;
    UINT TextLen;
} TAG, *PTAG;

TAG g_TagList[] = {
    {COMMAND_BOLD,          TEXT("B"),      0},
    {COMMAND_BOLD_END,      TEXT("/B"),     0},
    {COMMAND_UNDERLINE,     TEXT("U"),      0},
    {COMMAND_UNDERLINE_END, TEXT("/U"),     0},
    {COMMAND_HORZ_RULE,     TEXT("HR"),     0},
    {COMMAND_ANCHOR,        TEXT("A"),      0},
    {COMMAND_ANCHOR_END,    TEXT("/A"),     0},
    {COMMAND_INDENT,        TEXT("UL"),     0},
    {COMMAND_UNINDENT,      TEXT("/UL"),    0},
    {COMMAND_LIST_ITEM,     TEXT("LI"),     0},
    {COMMAND_LIST_ITEM_END, TEXT("/LI"),    0},
    {COMMAND_LINE_BREAK,    TEXT("BR"),     0},
    {COMMAND_PARAGRAPH,     TEXT("P"),      0},
    {0,                     NULL,           0}
};

#define MAX_URL         4096
#define MAX_BOOKMARK    128

typedef struct {
    RECT Rect;
    TCHAR Url[MAX_URL];
    TCHAR Bookmark[MAX_BOOKMARK];
} HOTLINK, *PHOTLINK;


PCTSTR
pParseHtmlArgs (
    IN      PCTSTR Start,
    IN      PCTSTR End
    )
{
    PTSTR MultiSz;
    PCTSTR ArgStart;
    PCTSTR ArgEnd;
    PTSTR p;
    BOOL Quotes;
    UINT Size;
    CHARTYPE ch;

    Size = (End - Start) * 2;
    MultiSz = AllocPathString (Size);
    if (!MultiSz) {
        return NULL;
    }

    p = MultiSz;

    do {
        while (*Start && _istspace (_tcsnextc (Start))) {
            Start = _tcsinc (Start);
        }

        if (*Start == 0) {
            break;
        }

        ArgStart = Start;
        ArgEnd = ArgStart;
        Quotes = FALSE;

        while (*ArgEnd) {
            if (_tcsnextc (ArgEnd) == TEXT('\"')) {
                Quotes = !Quotes;
            } else if (!Quotes) {
                ch = _tcsnextc (ArgEnd);
                if (_istspace (ch) || ch == TEXT('>')) {
                    break;
                }
            }

            ArgEnd = _tcsinc (ArgEnd);
        }

        if (ArgEnd > ArgStart) {
            StringCopyAB (p, ArgStart, ArgEnd);
            p = GetEndOfString (p) + 1;
        }

        Start = ArgEnd;

    } while (*Start && _tcsnextc (Start) != TEXT('>'));

    *p = 0;
    MYASSERT ((UINT) (p - MultiSz) < Size);

    return MultiSz;
}

PCTSTR
pGetNextHtmlToken (
    IN      PCTSTR Arg,
    OUT     PTSTR Key,
    IN      PCTSTR Delimiters       OPTIONAL
    )
{
    BOOL Quotes;
    PCTSTR ArgStart, ArgEnd, ArgEndSpaceTrimmed;
    PCTSTR ArgStartPlusOne;
    PCTSTR Delim;
    CHARTYPE ch;

    ArgStart = SkipSpace (Arg);
    ArgEnd = ArgStart;
    ArgEndSpaceTrimmed = ArgEnd;
    Quotes = FALSE;

    while (*ArgEnd) {
        ch = _tcsnextc (ArgEnd);

        if (Delimiters) {
            Delim = Delimiters;
            while (*Delim) {
                if (ch == _tcsnextc (Delim)) {
                    break;
                }
                Delim = _tcsinc (Delim);
            }

            if (*Delim) {
                ch = 0;
            }
        }

        if (ch == 0) {
            break;
        }

        if (!_istspace (ch)) {
            ArgEndSpaceTrimmed = ArgEnd;
        }

        ArgEnd = _tcsinc (ArgEnd);
    }

    //
    // Copy arg, stripping surrounding quotes
    //

    ArgEndSpaceTrimmed = _tcsinc (ArgEndSpaceTrimmed);

    if (_tcsnextc (Key) != TEXT('\"')) {
        StringCopyAB (Key, ArgStart, ArgEndSpaceTrimmed);
    } else {
        ArgEndSpaceTrimmed = _tcsdec2 (ArgStart, ArgEndSpaceTrimmed);
        if (!ArgEndSpaceTrimmed) {
            ArgEndSpaceTrimmed = ArgStart;
        } else if (_tcsnextc (ArgEndSpaceTrimmed) != TEXT('\"')) {
            ArgEndSpaceTrimmed = _tcsinc (ArgEndSpaceTrimmed);
        }

        ArgStartPlusOne = _tcsinc (ArgStart);
        StringCopyAB (Key, ArgStartPlusOne, ArgEndSpaceTrimmed);
    }

    if (*ArgEnd) {
        ArgEnd = _tcsinc (ArgEnd);
    }

    return ArgEnd;
}

VOID
pGetHtmlKeyAndValue (
    IN      PCTSTR Arg,
    OUT     PTSTR Key,
    OUT     PTSTR Value
    )
{
    PTSTR p;

    Arg = pGetNextHtmlToken (Arg, Key, TEXT("="));
    MYASSERT (Arg);

    if (_tcsnextc (Arg) == TEXT('\"')) {
        //
        // De-quote the arg
        //

        StringCopy (Value, _tcsinc (Arg));
        p = _tcsrchr (Value, 0);
        p = _tcsdec2 (Value, p);
        if (p && _tcsnextc (p) == TEXT('\"')) {
            *p = 0;
        }

    } else {
        StringCopy (Value, Arg);
    }
}


PCTSTR
pGetHtmlCommandOrChar (
    IN      PCTSTR String,
    OUT     CHARTYPE *Command,
    OUT     CHARTYPE *Char,
    OUT     PTSTR *CommandArg           OPTIONAL
    )

/*++

Routine Description:

  pGetHtmlCommandOrChar parses HTML text is String, returing the HTML tag
  command, printable character, pointer to the next token, HTML tag arguments
  and a pointer to the end of the current token.

Arguments:

  String - Specifies the string containing HTML

  Command - Receives the HTML tag command (COMMAND_* constant)
            or zero if the next token is not a tag

  Char - Receives the next printable character, or zero if the next token is
         not a printable character. Whitespace is both a command and a
         printable character. The rest are either one or the other.

  CommandArg - Receives a multi-sz of command arguments

Return Value:

  A pointer to the first non-whitespace character of the next token, or
  NULL if no more tokens exist.

--*/

{
    CHARTYPE ch;
    PCTSTR p, q;
    BOOL Quoted;
    CHARTYPE ch2;
    INT i;
    PCTSTR semicolon;

    if (CommandArg) {
        *CommandArg = NULL;
    }

    ch = _tcsnextc (String);
    *Command = 0;

    if (ch == 0) {
        i = 0;
    }

    if (_istspace (ch)) {

        *Command = COMMAND_WHITESPACE;
        ch = TEXT(' ');

    } else if (ch == TEXT('&')) {
        //
        // Convert HTML character escapes:
        //
        // &lt; &gt; &amp; &quot; &apos; &nbsp;
        //

        semicolon = _tcschr (String + 1, TEXT(';'));

        if (semicolon) {
            *Char = 0;

            if (StringMatchAB (TEXT("lt"), String + 1, semicolon)) {
                *Char = TEXT('<');
            } else if (StringMatchAB (TEXT("gt"), String + 1, semicolon)) {
                *Char = TEXT('>');
            } else if (StringMatchAB (TEXT("amp"), String + 1, semicolon)) {
                *Char = TEXT('&');
            } else if (StringMatchAB (TEXT("quot"), String + 1, semicolon)) {
                *Char = TEXT('\"');
            } else if (StringMatchAB (TEXT("apos"), String + 1, semicolon)) {
                *Char = TEXT('\'');
            } else if (StringMatchAB (TEXT("nbsp"), String + 1, semicolon)) {
                *Char = TEXT(' ');
            }

            if (*Char) {
                *Command = COMMAND_ESCAPED_CHAR;
                return _tcsinc (semicolon);
            }
        }
    } else if (ch == TEXT('<')) {

        p = SkipSpace (_tcsinc (String));
        ch = 0;

        if (*p) {

            q = NULL;

            for (i = 0 ; g_TagList[i].Text ; i++) {
                if (StringIMatchTcharCount (g_TagList[i].Text, p, g_TagList[i].TextLen)) {
                    q = p + g_TagList[i].TextLen;

                    ch2 = _tcsnextc (q);
                    if (!_istspace (ch2) && ch2 != TEXT('>')) {
                        continue;
                    }

                    Quoted = FALSE;
                    while (*q) {
                        ch2 = _tcsnextc (q);
                        if (ch2 == TEXT('\"')) {
                            Quoted = !Quoted;
                        } else if (!Quoted) {
                            if (ch2 == TEXT('>')) {
                                break;
                            }
                        }

                        q = _tcsinc (q);
                    }

                    if (*q) {
                        p += g_TagList[i].TextLen;
                        p = SkipSpace (p);
                        break;
                    }
                }
            }

            if (!g_TagList[i].Text) {
                //
                // Ignore unsupported tag
                //

                p = _tcschr (String, TEXT('>'));
                if (!p) {
                    p = GetEndOfString (String);
                }
            } else {
                //
                // Found a tag
                //

                String = p;
                *Command = g_TagList[i].Command;
                p = q;
                MYASSERT (p);

                if (CommandArg && String < p) {
                    *CommandArg = (PTSTR) pParseHtmlArgs (String, p);
                }
            }
        }

        String = p;
    }

    *Char = ch;

    //
    // Skip block of spaces
    //

    if (_istspace (ch)) {

        do {
            String = _tcsinc (String);
        } while (_istspace (_tcsnextc (String)));

        return *String ? String : NULL;
    } else if (*String) {
        return _tcsinc (String);
    }

    return NULL;
}

PCTSTR
pStripFormatting (
    PCTSTR String
    )
{
    PTSTR NewString;
    PCTSTR Start, p, q;
    PTSTR d;
    CHARTYPE Char, Command;
    UINT tchars;

    //
    // Duplicate String, removing the <B> and <U> commands
    //

    NewString = AllocPathString (SizeOfString (String));

    Start = String;
    d = NewString;
    p = Start;

    do {
        q = pGetHtmlCommandOrChar (p, &Command, &Char, NULL);

        if (!Char || Command == COMMAND_WHITESPACE || Command == COMMAND_ESCAPED_CHAR) {
            if (Start < p) {
                tchars = p - Start;
                CopyMemory (d, Start, tchars * sizeof (TCHAR));
                d += tchars;
            }

            if (Char) {
                *d++ = (TCHAR) Char;
            }

            Start = q;
        }

        p = q;
    } while (p);

    *d = 0;

    return NewString;
}


VOID
pCreateFontsIfNecessary (
    HDC hdc,
    HFONT BaseFont,
    PTEXTMETRIC ptm,
    HFONT *hFontNormal,
    HFONT *hFontBold,
    HFONT *hFontUnderlined
    )
{
    LOGFONT lf;
    TCHAR FaceName[LF_FACESIZE];
    SIZE Extent;

    if (!BaseFont) {
        BaseFont = GetStockObject (DEFAULT_GUI_FONT);
    }

    if (BaseFont) {
        SelectObject (hdc, BaseFont);
    }
    GetTextMetrics (hdc, ptm);

    if (!(*hFontNormal)) {
        ZeroMemory (&lf, sizeof (lf));
        GetTextFace (hdc, LF_FACESIZE, FaceName);
        GetObject (BaseFont, sizeof (lf), &lf);

        lf.lfHeight = ptm->tmHeight;
        lf.lfWeight = FW_NORMAL;
        StringCopy (lf.lfFaceName, FaceName);
        *hFontNormal = CreateFontIndirect (&lf);

        lf.lfWeight = FW_BOLD;
        *hFontBold = CreateFontIndirect (&lf);

        lf.lfWeight = FW_NORMAL;
        lf.lfUnderline = 1;
        *hFontUnderlined = CreateFontIndirect (&lf);

        SelectObject (hdc, *hFontNormal);
        GetTextExtentPoint32 (hdc, g_HangingIndentString, TcharCount (g_HangingIndentString), &Extent);
        g_HangingIndentPixels = Extent.cx;

        if (GetACP() == 932) {
            g_FarEastFudgeFactor = ptm->tmAveCharWidth;
        } else {
            g_FarEastFudgeFactor = 0;
        }

    }
}

INT
pComputeCharBytes (
    IN      CHARTYPE Char
    )
{
    if ((WORD) Char > 255) {
        return 2;
    }
    return 1;
}


typedef struct {
    BOOL InListItem;
    INT InUnorderedList;
    BOOL NextLineBlank;
    BOOL LastWasBlankLine;
} PARSESTATE, *PPARSESTATE;

PCTSTR
pFindFirstCharThatDoesNotFit (
    IN      INT Margin,
    IN      PGROWLIST ListPtr,
    IN      PGROWBUFFER AttribsList,
    IN      HASHTABLE BookmarkTable,
    IN      HWND hwnd,
    IN      HFONT hFontNormal,
    IN      HFONT hFontBold,
    IN      HFONT hFontUnderlined,
    IN      PCTSTR p,
    IN      INT x,
    OUT     PTEXTMETRIC ptm,
    OUT     PRECT prect,
    IN OUT  PLINEATTRIBS LineAttribs,
    IN OUT  PPARSESTATE ParseState
    )
{
    HDC hdc;
    PCTSTR endOfLine;
    PCTSTR wordWrapBreakPos;
    PCTSTR q;
    PCTSTR Arg;
    CHARTYPE Char, Command;
    SIZE Extent;
    UINT Size;
    PLINEATTRIBS PrevLineAttribs;
    SCROLLINFO si;
    PCTSTR FirstChar;
    PTSTR CommandBuf;
    PTSTR AnchorKey;
    PTSTR AnchorVal;
    UINT Count;
    INT ScrollBarPixels;
    BOOL PrevCharMb = FALSE;
    BOOL printableFound = FALSE;
    BOOL newLine;
    BOOL lastWasBlankLine;
    TCHAR oneChar;
    UINT prevCommand = 0;

    if (ParseState->NextLineBlank) {
        ParseState->LastWasBlankLine = TRUE;
        ParseState->NextLineBlank = FALSE;

        return p;
    }

    lastWasBlankLine = ParseState->LastWasBlankLine;
    ParseState->LastWasBlankLine = FALSE;

    //
    // Get display DC and initialize metrics
    //

    hdc = CreateDC (TEXT("display"), NULL, NULL, NULL);
    ParseState->NextLineBlank = FALSE;

    //
    // Select font of previous line
    //

    Size = GrowListGetSize (ListPtr);

    if (!Size) {
        if (hdc) {
            SelectObject (hdc, hFontNormal);
        }
        LineAttribs->LastCharAttribs = ATTRIB_NORMAL;
    } else {
        PrevLineAttribs = (PLINEATTRIBS) AttribsList->Buf + (Size - 1);
        LineAttribs->LastCharAttribs = PrevLineAttribs->LastCharAttribs;

        if (hdc) {
            if (PrevLineAttribs->LastCharAttribs == ATTRIB_BOLD) {
                SelectObject (hdc, hFontBold);
            } else if (PrevLineAttribs->LastCharAttribs == ATTRIB_UNDERLINED) {
                SelectObject (hdc, hFontUnderlined);
            } else {
                SelectObject (hdc, hFontNormal);
            }
        }
    }

    //
    // Get metrics
    //

    ZeroMemory (&si, sizeof (si));
    si.cbSize = sizeof (si);
    si.fMask = SIF_ALL;
    GetScrollInfo (hwnd, SB_VERT, &si);

    GetTextMetrics (hdc, ptm);
    GetClientRect (hwnd, prect);

    //
    // Account for scroll bar and right margin if scroll bar is
    // not yet visible
    //

    if (si.nMax < (INT) si.nPage || !si.nPage) {
        ScrollBarPixels = GetSystemMetrics (SM_CXVSCROLL);
        if (prect->right - prect->left > ScrollBarPixels * 2) {
            prect->right -= ScrollBarPixels;
        }
    }

    if (prect->right - prect->left > Margin * 2) {
        prect->right -= Margin;
    }

    //
    // Adjust if this is a far east system, because GetTextExtent doesn't
    // return the correct number of pixels.
    //

    prect->right -= g_FarEastFudgeFactor;

    //
    // Count characters until line is completely processed
    //

    MYASSERT (!_istspace (_tcsnextc (p)));

    FirstChar = p;
    endOfLine = p;
    wordWrapBreakPos = NULL;

    while (p && (INT) x < prect->right) {
        q = pGetHtmlCommandOrChar (
                p,                                  // current string position
                &Command,
                &Char,
                &CommandBuf
                );

        if (prevCommand == COMMAND_UNINDENT &&
            Command != COMMAND_UNINDENT &&
            Command != COMMAND_INDENT &&
            (Command != COMMAND_WHITESPACE || printableFound) &&
            Command != COMMAND_LINE_BREAK &&
            Command != COMMAND_PARAGRAPH &&
            !ParseState->InUnorderedList &&
            !lastWasBlankLine
            ) {

            Command = COMMAND_LINE_BREAK;
            q = p;
            Char = 0;
        }

        if (!Char) {

            if (q != p) {
                if (prevCommand == COMMAND_UNINDENT &&
                    Command == COMMAND_INDENT &&
                    !ParseState->InUnorderedList &&
                    !lastWasBlankLine
                    ) {

                    Command = COMMAND_LINE_BREAK;
                    q = p;

                } else if (ParseState->InListItem) {

                    MYASSERT (ParseState->InUnorderedList);

                    switch (Command) {

                    case COMMAND_PARAGRAPH:
                    case COMMAND_LINE_BREAK:
                    case COMMAND_UNINDENT:
                    case COMMAND_LIST_ITEM:
                        //
                        // Terminate the list item
                        //

                        Command = COMMAND_LIST_ITEM_END;
                        q = p;
                        break;
                    }

                } else if (Command == COMMAND_INDENT) {

                    //
                    // Before indenting, start a new line
                    //

                    if (printableFound) {
                        Command = COMMAND_LINE_BREAK;
                        q = p;
                    }

                } else if (Command == COMMAND_UNINDENT) {
                    //
                    // Before unindenting, complete the current line
                    //

                    if (printableFound) {
                        Command = COMMAND_LINE_BREAK;
                        q = p;
                    }
                }
            }

            //
            // Process tag
            //

            newLine = FALSE;

            switch (Command) {
            case 0:
                break;

            case COMMAND_BOLD:
                if (hdc) {
                    SelectObject (hdc, hFontBold);
                }
                LineAttribs->LastCharAttribs = ATTRIB_BOLD;
                break;

            case COMMAND_UNDERLINE:
                if (hdc) {
                    SelectObject (hdc, hFontUnderlined);
                }
                LineAttribs->LastCharAttribs = ATTRIB_UNDERLINED;
                break;

            case COMMAND_PARAGRAPH:
                ParseState->NextLineBlank = TRUE;
                newLine = TRUE;
                break;

            case COMMAND_LINE_BREAK:
            case COMMAND_HORZ_RULE:
                newLine = TRUE;
                break;

            case COMMAND_INDENT:
                ParseState->InUnorderedList += 1;

                if ((INT) (LineAttribs->Indent) < ptm->tmHeight * 20) {
                    LineAttribs->Indent += ptm->tmHeight * 2;
                    x += ptm->tmHeight * 2;
                }
                break;

            case COMMAND_LIST_ITEM:
                if (ParseState->InUnorderedList) {
                    LineAttribs->HangingIndent += g_HangingIndentPixels;
                    ParseState->InListItem = TRUE;
                }
                break;

            case COMMAND_LIST_ITEM_END:
                if (ParseState->InUnorderedList) {
                    LineAttribs->HangingIndent -= g_HangingIndentPixels;
                    ParseState->InListItem = FALSE;
                    newLine = TRUE;
                }

                break;

            case COMMAND_UNINDENT:
                if (ParseState->InUnorderedList) {
                    MYASSERT (!(ParseState->InListItem));

                    ParseState->InUnorderedList -= 1;

                    if ((INT) (LineAttribs->Indent) > ptm->tmHeight * 2) {
                        LineAttribs->Indent -= ptm->tmHeight * 2;
                        x -= ptm->tmHeight * 2;
                    }

                    //if (!lastWasBlankLine || printableFound) {
                    //    newLine = TRUE;
                    //}
                }
                break;

            case COMMAND_ANCHOR:
                if (CommandBuf) {
                    Arg = CommandBuf;

                    while (*Arg) {
                        //
                        // Search for a NAME arg
                        //

                        Count = TcharCount (Arg);
                        AnchorKey = AllocText (Count);
                        AnchorVal = AllocText (Count);

                        if (!AnchorKey || !AnchorVal) {
                            FreeText (AnchorKey);
                            FreeText (AnchorVal);
                            break;
                        }

                        pGetHtmlKeyAndValue (Arg, AnchorKey, AnchorVal);

                        if (StringIMatch (TEXT("NAME"), AnchorKey)) {

                            HtAddStringAndData (BookmarkTable, AnchorVal, &Size);

                        } else if (StringIMatch (TEXT("HREF"), AnchorKey)) {
                            LineAttribs->AnchorWrap = TRUE;
                        }

                        FreeText (AnchorKey);
                        FreeText (AnchorVal);

                        Arg += Count + 1;
                    }
                }

                break;

            case COMMAND_ANCHOR_END:
                LineAttribs->AnchorWrap = FALSE;
                break;

            case COMMAND_BOLD_END:
            case COMMAND_UNDERLINE_END:
                if (hdc) {
                    SelectObject (hdc, hFontNormal);
                }
                LineAttribs->LastCharAttribs = ATTRIB_NORMAL;
                break;
            }

            FreePathString (CommandBuf);

            prevCommand = Command;

            if (newLine) {
                if (q) {
                    endOfLine = q;
                } else {
                    endOfLine = GetEndOfString (p);
                }

                wordWrapBreakPos = NULL;
                break;
            }

        } else {
            //
            // Char is non-zero, so display it
            //

            if (printableFound || Command != COMMAND_WHITESPACE) {

                printableFound = TRUE;
                prevCommand = Command;

                if (Command) {
                    oneChar = (TCHAR) Char;
                    GetTextExtentPoint32 (hdc, &oneChar, 1, &Extent);
                } else {
                    GetTextExtentPoint32 (hdc, p, pComputeCharBytes (Char), &Extent);
                }
                x += Extent.cx;

                if (_istspace (Char)) {
                    wordWrapBreakPos = q;
                } else if (IsLeadByte (*q)) {
                    if (PrevCharMb && !IsPunct (_tcsnextc (q))) {
                        wordWrapBreakPos = q;
                    }
                    PrevCharMb = TRUE;
                } else {
                    PrevCharMb = FALSE;
                }
            }
        }

        if (q) {
            endOfLine = q;
        } else {
            endOfLine = GetEndOfString (endOfLine);
            wordWrapBreakPos = NULL;
        }

        p = q;
    }

    DeleteDC (hdc);

    if (wordWrapBreakPos) {
        return wordWrapBreakPos;
    }

    return endOfLine;
}


VOID
pRegisterHotLink (
    IN      PGROWBUFFER HotLinkArray,
    IN      PRECT HotRect,
    IN      PCTSTR UrlLink,
    IN      PCTSTR BookmarkLink
    )
{
    PHOTLINK HotLink;

    HotLink = (PHOTLINK) GrowBuffer (HotLinkArray, sizeof (HOTLINK));
    if (!HotLink) {
        return;
    }

    HotLink->Rect = *HotRect;

    if (UrlLink) {
        StringCopy (HotLink->Url, UrlLink);
    } else {
        HotLink->Url[0] = 0;
    }

    if (BookmarkLink) {
        StringCopy (HotLink->Bookmark, BookmarkLink);
    } else {
        HotLink->Bookmark[0] = 0;
    }
}


PHOTLINK
pFindHotLink (
    IN      PGROWBUFFER HotLinkArray,
    IN      UINT x,
    IN      UINT y
    )
{
    PHOTLINK HotLink;
    UINT u;

    HotLink = (PHOTLINK) HotLinkArray->Buf;

    for (u = 0 ; u < HotLinkArray->End ; u += sizeof (HOTLINK)) {
        if (x >= (UINT) HotLink->Rect.left && x < (UINT) HotLink->Rect.right &&
            y >= (UINT) HotLink->Rect.top && y < (UINT) HotLink->Rect.bottom
            ) {
            break;
        }

        HotLink++;
    }

    if (u >= HotLinkArray->End) {
        HotLink = NULL;
    }

    return HotLink;
}

BOOL
pLaunchedAddRemovePrograms (
    IN      PCTSTR CmdLine
    )
{
    return CmdLine && _tcsstr (CmdLine, TEXT("appwiz.cpl"));
}


typedef struct {
    HASHTABLE BookmarkTable;
    UINT LineHeight;
    HFONT hFont;
    HFONT hFontNormal;
    HFONT hFontBold;
    HFONT hFontUnderlined;
    GROWLIST List;
    GROWBUFFER AttribsList;
    GROWBUFFER HotLinkArray;
    BOOL UrlEnabled;
    INT Margin;
    PARSESTATE ParseState;
} TEXTVIEW_STATE, *PTEXTVIEW_STATE;

LRESULT
CALLBACK
TextViewProc (
    HWND hwnd,
    UINT uMsg,
    WPARAM wParam,
    LPARAM lParam
    )
{
    PAINTSTRUCT ps;
    HDC hdc;
    TEXTMETRIC tm;
    SCROLLINFO si;
    RECT rect;
    RECT FillRect;
    UINT Pos;
    UINT End;
    INT x, y;
    INT i;
    PCTSTR TrueStart, Start, Last;
    PCTSTR p, q;
    UINT Tchars;
    CHARTYPE Char, Command;
    UINT PrevHangingIndent;
    SIZE Extent;
    PLINEATTRIBS LineAttribs;
    PLINEATTRIBS PrevLineAttribs;
    HPEN OldPen;
    HBRUSH FillBrush;
    HPEN ShadowPen;
    HPEN HighlightPen;
    PTEXTVIEW_STATE s;
    UINT LineHeight;
    PHOTLINK HotLink;
    BOOL Hot;
    RECT HotRect;
    PCTSTR UrlLink;
    PCTSTR BookmarkLink;
    PTSTR CommandBuf;
    PCTSTR Arg;
    TCHAR Href[MAX_URL];
    PTSTR AnchorKey;
    PTSTR AnchorVal;
    UINT Count;
    HKEY TempKey;
    DWORD GrowListSize;
    PCTSTR ShellArgs;
    LONG l;
    BOOL b;
    PTSTR text;
    UINT textSize;
    BOOL printableFound;
    TCHAR oneChar;

    s = (PTEXTVIEW_STATE) GetWindowLong (hwnd, GWL_USERDATA);
    if (s) {
        LineHeight = s->LineHeight;
    } else {
        LineHeight = 0;
    }

    switch (uMsg) {

    case WM_CREATE:
        for (i = 0 ; g_TagList[i].Text ; i++) {
            g_TagList[i].TextLen = TcharCount (g_TagList[i].Text);
        }

        s = (PTEXTVIEW_STATE) MemAlloc (g_hHeap, HEAP_ZERO_MEMORY, sizeof (TEXTVIEW_STATE));
        SetWindowLong (hwnd, GWL_USERDATA, (LONG) s);

        TempKey = OpenRegKeyStr (TEXT("HKCR\\.URL"));
        if (TempKey) {
            CloseRegKey (TempKey);
        }

        s->UrlEnabled = (TempKey != NULL);

        ZeroMemory (&si, sizeof (si));
        si.fMask = SIF_RANGE;

        s->BookmarkTable = HtAllocWithData (sizeof (DWORD));
        if (!s->BookmarkTable) {
            return -1;
        }

        // WM_SETFONT does a bunch of work, including populating the text
        SendMessage (
            hwnd,
            WM_SETFONT,
            SendMessage (GetParent (hwnd), WM_GETFONT, 0, 0),
            0
            );

        return 0;

    case WM_GETDLGCODE:
        return DLGC_WANTARROWS;

    case WMX_GOTO:
        //
        // Determine if text is in bookmark table
        //

        if (!lParam) {
            return 0;
        }

        if (HtFindStringAndData (s->BookmarkTable, (PCTSTR) lParam, &Pos)) {

            PostMessage (
                hwnd,
                WM_VSCROLL,
                MAKELPARAM (SB_THUMBPOSITION, (WORD) Pos),
                (LPARAM) hwnd
                );

        }

        return 0;


    case WMX_ADDLINE:
        //
        // Init
        //

        l = GetWindowLong (hwnd, GWL_STYLE) & WS_BORDER;
        if (!l) {
            l = GetWindowLong (hwnd, GWL_EXSTYLE) & (WS_EX_DLGMODALFRAME|WS_EX_WINDOWEDGE|WS_EX_CLIENTEDGE|WS_EX_STATICEDGE);
        }

        if (!s->Margin && l) {
            s->Margin = s->LineHeight / 2;
        }

        Start = (PCTSTR) lParam;

        // ignore leading space
        TrueStart = Start;

        while (_istspace (_tcsnextc (Start))) {
            Start = _tcsinc (Start);
        }

        PrevLineAttribs = NULL;
        if (s->AttribsList.End) {
            MYASSERT (s->AttribsList.End >= sizeof (LINEATTRIBS));
            PrevLineAttribs = (PLINEATTRIBS) (s->AttribsList.Buf +
                                              s->AttribsList.End -
                                              sizeof (LINEATTRIBS)
                                              );
        }

        //
        // Copy line attributes (optional) to our Attribs list; ignore errors.
        //

        LineAttribs = (PLINEATTRIBS) GrowBuffer (&s->AttribsList, sizeof (LINEATTRIBS));
        if (!LineAttribs) {
            return 0;
        }

        //
        // Copy previous line's attributes
        //

        ZeroMemory (LineAttribs, sizeof (LINEATTRIBS));

        if (PrevLineAttribs) {
            LineAttribs->AnchorWrap    = PrevLineAttribs->AnchorWrap;
            LineAttribs->Indent        = PrevLineAttribs->Indent;
            LineAttribs->HangingIndent = PrevLineAttribs->HangingIndent;
            PrevHangingIndent = PrevLineAttribs->HangingIndent;
        } else {
            LineAttribs->Indent = s->Margin;
            LineAttribs->HangingIndent = 0;
            PrevHangingIndent = 0;
        }

        x = LineAttribs->Indent + PrevHangingIndent;

        //
        // Find the first character that does not fit on the line
        //

        Last = pFindFirstCharThatDoesNotFit (
                    s->Margin,
                    &s->List,
                    &s->AttribsList,
                    s->BookmarkTable,
                    hwnd,
                    s->hFontNormal,
                    s->hFontBold,
                    s->hFontUnderlined,
                    Start,
                    (INT) x,
                    &tm,
                    &rect,
                    LineAttribs,
                    &s->ParseState
                    );

        //
        // Update the vertical scroll bar
        //

        MYASSERT (LineHeight);

        ZeroMemory (&si, sizeof (si));
        si.cbSize = sizeof (si);
        si.fMask = SIF_RANGE|SIF_PAGE;
        si.nMin = 0;
        si.nPage = rect.bottom / LineHeight;
        si.nMax = GrowListGetSize (&s->List);

        SetScrollInfo (hwnd, SB_VERT, &si, TRUE);

        //
        // Copy the string (or as much that is visible) to our
        // grow list
        //

        GrowListAppendStringAB (&s->List, Start, Last);

        //
        // Return the number of bytes copied
        //

        return Last - TrueStart;

    case WMX_ALL_LINES_PAINTED:
        //
        // Scan all the lines, returning 0 if at least one has Painted == FALSE
        //

        LineAttribs = (PLINEATTRIBS) s->AttribsList.Buf;
        if (!LineAttribs) {
            return 1;
        }

        for (Pos = 0 ; Pos < s->AttribsList.End ; Pos += sizeof (LINEATTRIBS)) {
            LineAttribs = (PLINEATTRIBS) (s->AttribsList.Buf + Pos);
            if (!LineAttribs->Painted) {
                return 0;
            }
        }

        return 1;

    case WM_ERASEBKGND:
        return 0;

    case WM_KEYDOWN:
        switch (wParam) {
        case VK_DOWN:
            PostMessage (hwnd, WM_VSCROLL, SB_LINEDOWN, 0);
            return 0;

        case VK_UP:
            PostMessage (hwnd, WM_VSCROLL, SB_LINEUP, 0);
            return 0;

        case VK_NEXT:
            PostMessage (hwnd, WM_VSCROLL, SB_PAGEDOWN, 0);
            return 0;

        case VK_PRIOR:
            PostMessage (hwnd, WM_VSCROLL, SB_PAGEUP, 0);
            return 0;

        case VK_HOME:
            PostMessage (hwnd, WM_VSCROLL, SB_TOP, 0);
            return 0;

        case VK_END:
            PostMessage (hwnd, WM_VSCROLL, SB_BOTTOM, 0);
            return 0;
        }

        break;


    case WM_SETFONT:
        s->hFont = (HFONT) wParam;

        if (s->hFontNormal) {
            DeleteObject (s->hFontNormal);
            s->hFontNormal = NULL;
        }

        if (s->hFontBold) {
            DeleteObject (s->hFontBold);
            s->hFontBold = NULL;
        }

        if (s->hFontUnderlined) {
            DeleteObject (s->hFontUnderlined);
            s->hFontUnderlined = NULL;
        }

        hdc = CreateDC (TEXT("display"), NULL, NULL, NULL);
        if (hdc) {
            pCreateFontsIfNecessary (hdc, s->hFont, &tm, &s->hFontNormal, &s->hFontBold, &s->hFontUnderlined);
            s->LineHeight = tm.tmHeight;

            DeleteDC (hdc);
        } else {
            s->LineHeight = 0;
        }

        if (lParam) {
            InvalidateRect (hwnd, NULL, FALSE);
        }

        if (s->AttribsList.End == 0) {
            textSize = GetWindowTextLength (hwnd);
            text = (PTSTR) MemAllocUninit ((textSize + 1) * sizeof (TCHAR));
            GetWindowText (hwnd, text, textSize + 1);
            AddStringToTextView (hwnd, text);
            FreeMem (text);
        }

        return 0;


    case WM_MOUSEMOVE:
        //
        // Search array of hit test rectangles
        //

        x = LOWORD(lParam);
        y = HIWORD(lParam);

        HotLink = pFindHotLink (&s->HotLinkArray, x, y);

        if (HotLink) {
            SetCursor (LoadCursor (g_hInst, MAKEINTRESOURCE (IDC_OUR_HAND)));
        } else {
            SetCursor (LoadCursor (NULL, MAKEINTRESOURCE (IDC_ARROW)));
        }

        break;

    case WM_LBUTTONDOWN:
        //
        // Search array of hit test rectangles
        //

        x = LOWORD(lParam);
        y = HIWORD(lParam);

        HotLink = pFindHotLink (&s->HotLinkArray, x, y);

        if (HotLink) {
            if (HotLink->Url[0]) {
                if (!StringIMatchCharCount (TEXT("file:"), HotLink->Url, 5)) {
                    ShellExecute (hwnd, TEXT("open"), HotLink->Url, NULL, NULL, 0);
                } else {
                    ShellArgs = &HotLink->Url[5];
                    if (*ShellArgs == TEXT('/')) {
                        ShellArgs++;
                    }
                    if (*ShellArgs == TEXT('/')) {
                        ShellArgs++;
                    }

                    ShellArgs = ExtractArgZero (ShellArgs, Href);
                    //
                    // if we're launching the Add/Remove programs applet,
                    // warn users they'll have to restart setup (RAID # 293357)
                    //
                    b = TRUE;
                    if (!UNATTENDED() &&
                        !REPORTONLY() &&
                        !g_UIQuitSetup &&
                        pLaunchedAddRemovePrograms (ShellArgs)
                        ) {
                        if (IDYES == ResourceMessageBox (
                                        hwnd,
                                        MSG_RESTART_IF_CONTINUE_APPWIZCPL,
                                        MB_YESNO | MB_ICONQUESTION,
                                        NULL
                                        )) {
                            LOG ((LOG_INFORMATION, "User launched Add/Remove Programs applet; setup will terminate"));
                            PostMessage (GetParent (hwnd), WMX_RESTART_SETUP, FALSE, TRUE);
                        } else {
                            b = FALSE;
                        }
                    }
                    if (b) {
                        ShellExecute (hwnd, TEXT("open"), Href, ShellArgs, NULL, 0);
                    }
                }
            } else if (HotLink->Bookmark) {
                SendMessage (hwnd, WMX_GOTO, 0, (LPARAM) HotLink->Bookmark);
            }
        }

        break;

    case WM_SETTEXT:
        SendMessage (hwnd, WMX_CLEANUP, 0, 0);
        DefWindowProc (hwnd, uMsg, wParam, lParam);
        SendMessage (hwnd, WM_CREATE, 0, 0);
        return 0;

    case WM_PAINT:
        FillBrush = CreateSolidBrush (GetSysColor (COLOR_BTNFACE));
        ShadowPen = CreatePen (PS_SOLID, 1, GetSysColor (COLOR_3DSHADOW));
        HighlightPen = CreatePen (PS_SOLID, 1, GetSysColor (COLOR_3DHILIGHT));

        hdc = BeginPaint (hwnd, &ps);
        pCreateFontsIfNecessary (hdc, s->hFont, &tm, &s->hFontNormal, &s->hFontBold, &s->hFontUnderlined);
        s->LineHeight = LineHeight = tm.tmHeight;
        GetClientRect (hwnd, &rect);

        //
        // Select colors
        //

        SetBkColor (hdc, GetSysColor (COLOR_BTNFACE));
        SetTextColor (hdc, GetSysColor (COLOR_WINDOWTEXT));

        if (FillBrush) {
            SelectObject (hdc, FillBrush);
        }

        SelectObject (hdc, GetStockObject (NULL_PEN));

        //
        // Get scroll position
        //

        ZeroMemory (&si, sizeof (si));
        si.cbSize = sizeof (si);
        si.fMask = SIF_PAGE|SIF_POS;
        GetScrollInfo (hwnd, SB_VERT, &si);

        End = (UINT) si.nPos + si.nPage + 1;
        GrowListSize = GrowListGetSize (&s->List);
        End = min (End, GrowListSize);
        y = 0;

        //
        // Select font of previous line.  Move up if anchor wrap is on.
        //

        if (si.nPos) {
            do {
                LineAttribs = (PLINEATTRIBS) s->AttribsList.Buf + (si.nPos - 1);
                if (LineAttribs->AnchorWrap) {
                    si.nPos--;
                    y -= LineHeight;
                } else {
                    break;
                }
            } while (si.nPos > 0);
        }

        if (si.nPos) {
            LineAttribs = (PLINEATTRIBS) s->AttribsList.Buf + (si.nPos - 1);

            if (LineAttribs->LastCharAttribs == ATTRIB_BOLD) {
                SelectObject (hdc, s->hFontBold);
            } else if (LineAttribs->LastCharAttribs == ATTRIB_UNDERLINED) {
                SelectObject (hdc, s->hFontUnderlined);
            } else {
                SelectObject (hdc, s->hFontNormal);
            }
        } else {
            SelectObject (hdc, s->hFontNormal);
        }

        //
        // Paint!
        //

        Hot = FALSE;
        s->HotLinkArray.End = 0;
        BookmarkLink = UrlLink = NULL;

        for (Pos = (UINT) si.nPos ; Pos < End ; Pos++) {
            p = GrowListGetString (&s->List, Pos);
            printableFound = FALSE;

            LineAttribs = (PLINEATTRIBS) s->AttribsList.Buf + Pos;

            //
            // Compute hanging indent using previous line
            //

            if (Pos > 0) {
                PrevLineAttribs = (PLINEATTRIBS) ((PLINEATTRIBS) s->AttribsList.Buf + Pos - 1);
                PrevHangingIndent = PrevLineAttribs->HangingIndent;
            } else {
                PrevHangingIndent = 0;
            }

            //
            // Compute starting index
            //

            if (LineAttribs) {
                x = LineAttribs->Indent + PrevHangingIndent;
                LineAttribs->Painted = TRUE;
            } else {
                x = s->Margin;
            }

            //
            // Compute blank area
            //

            if (x > 0) {
                FillRect.left = 0;
                FillRect.right = x;
                FillRect.top = y;
                FillRect.bottom = y + LineHeight;

                Rectangle (hdc, FillRect.left, FillRect.top, FillRect.right + 1, FillRect.bottom + 1);
            }

            //
            // Multiline hotlink
            //

            if (Hot) {
                HotRect.left = x;
                HotRect.top = y;
            }

            //
            // Compute text block
            //

            Start = p;

            while (p) {
                q = pGetHtmlCommandOrChar (p, &Command, &Char, &CommandBuf);

                if (!Char || Command == COMMAND_WHITESPACE || Command == COMMAND_ESCAPED_CHAR) {
                    //
                    // If this is the end of of a block of text, paint it.
                    //

                    MYASSERT (Start);

                    Tchars = p - Start;

                    if (Tchars) {
                        TextOut (hdc, x, y, Start, Tchars);
                        GetTextExtentPoint32 (hdc, Start, Tchars, &Extent);

                        x += Extent.cx;
                        if (x > rect.right) {
                            break;
                        }
                    }

                    Start = q;
                    oneChar = 0;

                    if (printableFound && Command == COMMAND_WHITESPACE) {
                        oneChar = TEXT(' ');
                    } else if (Command == COMMAND_ESCAPED_CHAR) {
                        oneChar = (TCHAR) Char;
                    }

                    if (oneChar) {

                        TextOut (hdc, x, y, &oneChar, 1);
                        GetTextExtentPoint32 (hdc, &oneChar, 1, &Extent);

                        x += Extent.cx;
                        if (x > rect.right) {
                            break;
                        }
                    }

                } else {
                    printableFound = TRUE;
                }

                switch (Command) {
                case 0:
                case COMMAND_WHITESPACE:
                case COMMAND_ESCAPED_CHAR:
                    break;

                case COMMAND_ANCHOR:
                    //
                    // Does this anchor have an HREF?
                    //

                    if (CommandBuf) {
                        Arg = CommandBuf;

                        Href[0] = 0;

                        while (Href[0] == 0 && *Arg) {
                            //
                            // Search for a HREF arg
                            //

                            Count = TcharCount (Arg);
                            AnchorKey = AllocText (Count);
                            AnchorVal = AllocText (Count);

                            if (!AnchorKey || !AnchorVal) {
                                FreeText (AnchorKey);
                                FreeText (AnchorVal);
                                break;
                            }

                            pGetHtmlKeyAndValue (Arg, AnchorKey, AnchorVal);

                            if (StringIMatch (TEXT("HREF"), AnchorKey)) {
                                _tcssafecpy (Href, AnchorVal, MAX_URL);
                            }

                            FreeText (AnchorKey);
                            FreeText (AnchorVal);

                            Arg += Count + 1;
                        }

                        if (Href[0]) {
                            //
                            // Does HREF point to a bookmark?
                            //

                            BookmarkLink = UrlLink = NULL;

                            if (_tcsnextc (Href) == TEXT('#')) {
                                BookmarkLink = SkipSpace (_tcsinc (Href));
                            } else {
                                if (s->UrlEnabled) {
                                    UrlLink = Href;
                                }
                            }

                            //
                            // If either BookmarkLink or Url is non-NULL, then turn on
                            // link font and color
                            //

                            if (BookmarkLink || UrlLink) {
                                HotRect.left = x;
                                HotRect.top = y;
                                Hot = TRUE;

                                SelectObject (hdc, s->hFontUnderlined);
                                SetTextColor (hdc, GetSysColor (COLOR_HIGHLIGHT));
                            }
                        }
                    }

                    break;

                case COMMAND_BOLD:
                    SelectObject (hdc, s->hFontBold);
                    break;

                case COMMAND_UNDERLINE:
                    SelectObject (hdc, s->hFontUnderlined);
                    break;

                case COMMAND_HORZ_RULE:
                    FillRect.left = rect.left;
                    FillRect.right = rect.right;
                    FillRect.top = y;
                    FillRect.bottom = y + LineHeight;

                    Rectangle (hdc, FillRect.left, FillRect.top, FillRect.right + 1, FillRect.bottom + 1);

                    OldPen = (HPEN) SelectObject (hdc, ShadowPen);
                    MoveToEx (hdc, rect.left + 3, y + LineHeight / 2, NULL);
                    LineTo (hdc, rect.right - 3, y + LineHeight / 2);
                    SelectObject (hdc, HighlightPen);
                    MoveToEx (hdc, rect.left + 3, y + LineHeight / 2 + 1, NULL);
                    LineTo (hdc, rect.right - 3, y + LineHeight / 2 + 1);
                    SelectObject (hdc, OldPen);

                    x = rect.right;
                    break;

                case COMMAND_ANCHOR_END:
                    SelectObject (hdc, s->hFontNormal);
                    SetTextColor (hdc, GetSysColor (COLOR_WINDOWTEXT));

                    if (Hot) {
                        Hot = FALSE;
                        HotRect.right = x;
                        HotRect.bottom = y + LineHeight;

                        pRegisterHotLink (&s->HotLinkArray, &HotRect, UrlLink, BookmarkLink);
                    }
                    break;

                case COMMAND_BOLD_END:
                case COMMAND_UNDERLINE_END:
                    SelectObject (hdc, s->hFontNormal);
                    break;
                }

                FreePathString (CommandBuf);

                p = q;
            }

            //
            // Hot link that extends to multiple lines
            //

            if (Hot) {
                HotRect.right = x;
                HotRect.bottom = y + LineHeight;
                pRegisterHotLink (&s->HotLinkArray, &HotRect, UrlLink, BookmarkLink);
            }

            //
            // Fill blank area to end of line
            //

            if (x < rect.right) {
                FillRect.left = x;
                FillRect.right = rect.right;
                FillRect.top = y;
                FillRect.bottom = y + LineHeight;

                Rectangle (hdc, FillRect.left, FillRect.top, FillRect.right + 1, FillRect.bottom + 1);
            }

            y += LineHeight;
        }

        //
        // Fill blank area to bottom of window
        //

        if (y < rect.bottom) {
             FillRect.left = 0;
             FillRect.right = rect.right;
             FillRect.top = y;
             FillRect.bottom = rect.bottom;

             Rectangle (hdc, FillRect.left, FillRect.top, FillRect.right + 1, FillRect.bottom + 1);
        }

        //
        // Cleanup
        //

        if (FillBrush) {
            DeleteObject (FillBrush);
        }

        if (ShadowPen) {
            DeleteObject (ShadowPen);
            ShadowPen = NULL;
        }

        if (HighlightPen) {
            DeleteObject (HighlightPen);
            HighlightPen = NULL;
        }

        EndPaint (hwnd, &ps);
        return 0;

    case WM_VSCROLL:
        Pos = HIWORD (wParam);

        ZeroMemory (&si, sizeof (si));
        si.cbSize = sizeof (si);
        si.fMask = SIF_ALL;
        GetScrollInfo (hwnd, SB_VERT, &si);
        i = si.nMax - (INT) si.nPage + 1;

        si.fMask = 0;

        switch (LOWORD (wParam)) {
        case SB_PAGEDOWN:
            if (si.nPos + (INT) si.nPage < i) {
                si.nPos += si.nPage;
                ScrollWindow (hwnd, 0, -((INT) LineHeight * (INT) si.nPage), NULL, NULL);
                si.fMask = SIF_POS;
                break;
            }

            // fall through!

        case SB_BOTTOM:
            if (si.nPos < i) {
                InvalidateRect (hwnd, NULL, FALSE);
                si.nPos = i;
                si.fMask = SIF_POS;
            }
            break;

        case SB_LINEDOWN:
            if (si.nPos < i) {
                si.nPos += 1;
                ScrollWindow (hwnd, 0, -((INT) LineHeight), NULL, NULL);
                si.fMask = SIF_POS;
            }

            break;

        case SB_LINEUP:
            if (si.nPos > si.nMin) {
                si.nPos -= 1;
                ScrollWindow (hwnd, 0, (INT) LineHeight, NULL, NULL);
                si.fMask = SIF_POS;
            }

            break;

        case SB_THUMBTRACK:
        case SB_THUMBPOSITION:
            if ((INT) Pos != si.nPos) {
                InvalidateRect (hwnd, NULL, FALSE);
                si.nPos = (INT) Pos;
                si.fMask = SIF_POS;
            }
            break;

        case SB_PAGEUP:
            if (si.nPos >= si.nMin + (INT) si.nPage) {
                si.nPos -= si.nPage;
                ScrollWindow (hwnd, 0, (INT) LineHeight * si.nPage, NULL, NULL);
                si.fMask = SIF_POS;
                break;
            }

            // fall through

        case SB_TOP:
            if (si.nPos > si.nMin) {
                ScrollWindow (hwnd, 0, (INT) LineHeight * si.nPos, NULL, NULL);
                si.nPos = si.nMin;
                si.fMask = SIF_POS;
            }
            break;
        }

        if (si.fMask) {
            SetScrollInfo (hwnd, SB_VERT, &si, TRUE);
        }
        break;

    case WM_DESTROY:
    case WMX_CLEANUP:
        if (!g_Terminated) {
            if (s) {
                if (s->hFontNormal) {
                    DeleteObject (s->hFontNormal);
                    s->hFontNormal = NULL;
                }

                if (s->hFontBold) {
                    DeleteObject (s->hFontBold);
                    s->hFontBold = NULL;
                }

                if (s->hFontUnderlined) {
                    DeleteObject (s->hFontUnderlined);
                    s->hFontUnderlined = NULL;
                }

                FreeGrowBuffer (&s->AttribsList);
                FreeGrowBuffer (&s->HotLinkArray);
                FreeGrowList (&s->List);

                if (s->BookmarkTable) {
                    HtFree (s->BookmarkTable);
                    s->BookmarkTable = NULL;
                }

                MemFree (g_hHeap, 0, s);
                SetWindowLong (hwnd, GWL_USERDATA, 0);
            }
        }
        break;

    }

    return DefWindowProc (hwnd, uMsg, wParam, lParam);
}


VOID
RegisterTextViewer (
    VOID
    )
{
    static WNDCLASS wc;

    if (!wc.lpfnWndProc) {
        wc.lpfnWndProc = TextViewProc;
        wc.hInstance = g_hInst;
        wc.hCursor = NULL;
        wc.hbrBackground = (HBRUSH) COLOR_WINDOW;
        wc.lpszClassName = S_TEXTVIEW_CLASS;

        RegisterClass (&wc);

        //
        // We don't ever clean this up... and that's OK.
        //
    }
}



PCTSTR
AddLineToTextView (
    HWND hwnd,
    PCTSTR Text
    )
{
    PCTSTR TextEnd;

    TextEnd = Text + SendMessage (hwnd, WMX_ADDLINE, 0, (LPARAM) Text);

    if (*TextEnd == 0) {
        return NULL;
    }

    return TextEnd;
}

VOID
AddStringToTextView (
    IN      HWND hwnd,
    IN      PCTSTR String
    )
{
    PCTSTR p;

    if (!hwnd) {
        return;
    }

    if (String && *String) {
        for (p = String ; p ; p = AddLineToTextView (hwnd, p)) {
            // empty
        }
    }
}