able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/ntsetup/win95upg/w95upg/ui/textview.c

2037 lines
51 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
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
}
}
}
Reference in a new issue Copy permalink