Google Git
Sign in
goma / wine / 329f0680e4d3c04b2148a3955ed3a72b37ccbd33 / . / controls / edit.c
blob: d49bd0413a31670c315fa86abfea901848e93403 [file] [log] [blame]
/*
* Edit control
*
* Copyright David W. Metcalfe, 1994
* Copyright William Magro, 1995, 1996
* Copyright Frans van Dorsselaer, 1996
*
*/
/*
* UNDER CONSTRUCTION, please read EDIT.TODO
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#include "win.h"
#include "local.h"
#include "stackframe.h"
#include "stddebug.h"
#include "debug.h"
#include "xmalloc.h"
#include "callback.h"
#define BUFLIMIT_MULTI 65535 /* maximum text buffer length */
#define BUFLIMIT_SINGLE 32767 /* maximum text buffer length */
#define BUFSTART_MULTI 1024 /* starting length for multi-line control */
#define BUFSTART_SINGLE 256 /* starting length for single line control */
#define GROWLENGTH 64 /* buffers grow by this much */
#define HSCROLL_FRACTION 3 /* scroll window by 1/3 width */
typedef enum
{
END_0 = 0,
END_DELIMIT,
END_NONE,
END_HARD,
END_SOFT,
} LINE_END;
typedef struct {
int offset;
int length;
LINE_END ending;
} LINEDEF;
typedef struct
{
int TextWidth; /* width of the widest line in pixels */
HLOCAL hBuf;
char *text;
HFONT hFont;
LINEDEF *LineDefs;
int XOffset; /* possitive offset of the viewport in pixels */
int FirstVisibleLine;
int LineCount;
int LineHeight; /* height of a screen line in pixels */
int AveCharWidth; /* average character width in pixels */
unsigned int BufLimit;
unsigned int BufSize;
BOOL TextChanged;
BOOL Redraw;
int SelStart; /* offset of selection start, == SelEnd if no selection */
int SelEnd; /* offset of selection end == current caret position */
int NumTabStops;
LPINT TabStops;
EDITWORDBREAKPROC WordBreakProc;
char PasswordChar;
} EDITSTATE;
#define SWAP_INT(x,y) do { int temp = (x); (x) = (y); (y) = temp; } while(0)
#define ORDER_INT(x,y) do { if ((y) < (x)) SWAP_INT((x),(y)); } while(0)
/* macros to access window styles */
#define IsMultiLine(wndPtr) ((wndPtr)->dwStyle & ES_MULTILINE)
#define IsVScrollBar(wndPtr) ((wndPtr)->dwStyle & WS_VSCROLL)
#define IsHScrollBar(wndPtr) ((wndPtr)->dwStyle & WS_HSCROLL)
#define IsReadOnly(wndPtr) ((wndPtr)->dwStyle & ES_READONLY)
#define IsWordWrap(wndPtr) (((wndPtr)->dwStyle & ES_AUTOHSCROLL) == 0)
#define EDITSTATEPTR(wndPtr) (*(EDITSTATE **)((wndPtr)->wExtra))
#ifdef WINELIB32
#define EDIT_SEND_CTLCOLOR(wndPtr,hdc) \
SendMessage((wndPtr)->parent->hwndSelf, WM_CTLCOLOREDIT, \
(WPARAM)(hdc), (LPARAM)(wndPtr)->hwndSelf)
#define EDIT_NOTIFY_PARENT(wndPtr, wNotifyCode) \
SendMessage((wndPtr)->parent->hwndSelf, WM_COMMAND, \
MAKEWPARAM((wndPtr)->wIDmenu, wNotifyCode), \
(LPARAM)(wndPtr)->hwndSelf )
#define DPRINTF_EDIT_MSG(str) \
dprintf_edit(stddeb, \
"edit: " str ": hwnd=%08x, wParam=%08x, lParam=%08lx\n", \
(UINT)hwnd, (UINT)wParam, (DWORD)lParam)
#else
#define EDIT_SEND_CTLCOLOR(wndPtr,hdc) \
SendMessage((wndPtr)->parent->hwndSelf, WM_CTLCOLOR, \
(WPARAM)(hdc), MAKELPARAM((wndPtr)->hwndSelf, CTLCOLOR_EDIT))
#define EDIT_NOTIFY_PARENT(wndPtr, wNotifyCode) \
SendMessage((wndPtr)->parent->hwndSelf, WM_COMMAND, \
(wndPtr)->wIDmenu, \
MAKELPARAM((wndPtr)->hwndSelf, wNotifyCode))
#define DPRINTF_EDIT_MSG(str) \
dprintf_edit(stddeb, \
"edit: " str ": hwnd=%04x, wParam=%04x, lParam=%08lx\n", \
(UINT)hwnd, (UINT)wParam, (DWORD)lParam)
#endif
/*********************************************************************
*
* Declarations
*
* Files like these should really be kept in alphabetical order.
*
*/
LRESULT EditWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
static void EDIT_BuildLineDefs(WND *wndPtr);
static int EDIT_CallWordBreakProc(WND *wndPtr, char *s, int index, int count, int action);
static int EDIT_ColFromWndX(WND *wndPtr, int line, int x);
static void EDIT_DelEnd(WND *wndPtr);
static void EDIT_DelLeft(WND *wndPtr);
static void EDIT_DelRight(WND *wndPtr);
static int EDIT_GetAveCharWidth(WND *wndPtr);
static int EDIT_GetLineHeight(WND *wndPtr);
static void EDIT_GetLineRect(WND *wndPtr, int line, int scol, int ecol, LPRECT rc);
static char * EDIT_GetPointer(WND *wndPtr);
static LRESULT EDIT_GetRect(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static BOOL EDIT_GetRedraw(WND *wndPtr);
static int EDIT_GetTextWidth(WND *wndPtr);
static int EDIT_GetVisibleLineCount(WND *wndPtr);
static int EDIT_GetWndWidth(WND *wndPtr);
static int EDIT_GetXOffset(WND *wndPtr);
static int EDIT_LineFromWndY(WND *wndPtr, int y);
static BOOL EDIT_MakeFit(WND *wndPtr, int size);
static void EDIT_MoveBackward(WND *wndPtr, BOOL extend);
static void EDIT_MoveDownward(WND *wndPtr, BOOL extend);
static void EDIT_MoveEnd(WND *wndPtr, BOOL extend);
static void EDIT_MoveForward(WND *wndPtr, BOOL extend);
static void EDIT_MoveHome(WND *wndPtr, BOOL extend);
static void EDIT_MovePageDown(WND *wndPtr, BOOL extend);
static void EDIT_MovePageUp(WND *wndPtr, BOOL extend);
static void EDIT_MoveUpward(WND *wndPtr, BOOL extend);
static void EDIT_MoveWordBackward(WND *wndPtr, BOOL extend);
static void EDIT_MoveWordForward(WND *wndPtr, BOOL extend);
static void EDIT_PaintLine(WND *wndPtr, HDC hdc, int line);
static int EDIT_PaintText(WND *wndPtr, HDC hdc, int x, int y, int line, int col, int count, BOOL rev);
static void EDIT_ReleasePointer(WND *wndPtr);
static LRESULT EDIT_ReplaceSel(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static void EDIT_ScrollIntoView(WND *wndPtr);
static int EDIT_WndXFromCol(WND *wndPtr, int line, int col);
static int EDIT_WndYFromLine(WND *wndPtr, int line);
static int EDIT_WordBreakProc(char *s, int index, int count, int action);
static LRESULT EDIT_EM_CanUndo(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_EmptyUndoBuffer(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_FmtLines(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_GetFirstVisibleLine(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_GetHandle(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_GetLine(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_GetLineCount(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_GetModify(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_GetPasswordChar(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_GetRect(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_GetSel(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_GetThumb(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_GetWordBreakProc(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_LimitText(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_LineFromChar(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_LineIndex(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_LineLength(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_LineScroll(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_ReplaceSel(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_Scroll(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_SetHandle(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_SetModify(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_SetPasswordChar(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_SetReadOnly(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_SetRect(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_SetRectNP(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_SetSel(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_SetTabStops(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_SetWordBreakProc(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_EM_Undo(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_Char(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_Clear(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_Copy(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_Cut(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_Create(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_Destroy(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_Enable(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_EraseBkGnd(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_GetDlgCode(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_GetFont(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_GetText(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_GetTextLength(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_HScroll(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_KeyDown(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_KillFocus(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_LButtonDblClk(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_LButtonDown(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_LButtonUp(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_MouseMove(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_Paint(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_Paste(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_SetCursor(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_SetFocus(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_SetFont(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_SetRedraw(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_SetText(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_Size(WND *wndPtr, WPARAM wParam, LPARAM lParam);
static LRESULT EDIT_WM_VScroll(WND *wndPtr, WPARAM wParam, LPARAM lParam);
/*********************************************************************
*
* EditWndProc()
*
*/
LRESULT EditWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
LRESULT lResult = 0L;
WND *wndPtr = WIN_FindWndPtr(hwnd);
switch (msg) {
case EM_CANUNDO:
DPRINTF_EDIT_MSG("EM_CANUNDO");
lResult = EDIT_EM_CanUndo(wndPtr, wParam, lParam);
break;
case EM_EMPTYUNDOBUFFER:
DPRINTF_EDIT_MSG("EM_EMPTYUNDOBUFFER");
lResult = EDIT_EM_EmptyUndoBuffer(wndPtr, wParam, lParam);
break;
case EM_FMTLINES:
DPRINTF_EDIT_MSG("EM_FMTLINES");
lResult = EDIT_EM_FmtLines(wndPtr, wParam, lParam);
break;
case EM_GETFIRSTVISIBLELINE:
DPRINTF_EDIT_MSG("EM_GETFIRSTVISIBLELINE");
lResult = EDIT_EM_GetFirstVisibleLine(wndPtr, wParam, lParam);
break;
case EM_GETHANDLE:
DPRINTF_EDIT_MSG("EM_GETHANDLE");
lResult = EDIT_EM_GetHandle(wndPtr, wParam, lParam);
break;
case EM_GETLINE:
DPRINTF_EDIT_MSG("EM_GETLINE");
lResult = EDIT_EM_GetLine(wndPtr, wParam, lParam);
break;
case EM_GETLINECOUNT:
DPRINTF_EDIT_MSG("EM_GETLINECOUNT");
lResult = EDIT_EM_GetLineCount(wndPtr, wParam, lParam);
break;
case EM_GETMODIFY:
DPRINTF_EDIT_MSG("EM_GETMODIFY");
lResult = EDIT_EM_GetModify(wndPtr, wParam, lParam);
break;
case EM_GETPASSWORDCHAR:
DPRINTF_EDIT_MSG("EM_GETPASSWORDCHAR");
lResult = EDIT_EM_GetPasswordChar(wndPtr, wParam, lParam);
break;
case EM_GETRECT:
DPRINTF_EDIT_MSG("EM_GETRECT");
lResult = EDIT_EM_GetRect(wndPtr, wParam, lParam);
break;
case EM_GETSEL:
DPRINTF_EDIT_MSG("EM_GETSEL");
lResult = EDIT_EM_GetSel(wndPtr, wParam, lParam);
break;
case EM_GETTHUMB:
DPRINTF_EDIT_MSG("EM_GETTHUMB");
lResult = EDIT_EM_GetThumb(wndPtr, wParam, lParam);
break;
case EM_GETWORDBREAKPROC:
DPRINTF_EDIT_MSG("EM_GETWORDBREAKPROC");
lResult = EDIT_EM_GetWordBreakProc(wndPtr, wParam, lParam);
break;
case EM_LIMITTEXT:
DPRINTF_EDIT_MSG("EM_LIMITTEXT");
lResult = EDIT_EM_LimitText(wndPtr, wParam, lParam);
break;
case EM_LINEFROMCHAR:
DPRINTF_EDIT_MSG("EM_LINEFROMCHAR");
lResult = EDIT_EM_LineFromChar(wndPtr, wParam, lParam);
break;
case EM_LINEINDEX:
DPRINTF_EDIT_MSG("EM_LINEINDEX");
lResult = EDIT_EM_LineIndex(wndPtr, wParam, lParam);
break;
case EM_LINELENGTH:
DPRINTF_EDIT_MSG("EM_LINELENGTH");
lResult = EDIT_EM_LineLength(wndPtr, wParam, lParam);
break;
case EM_LINESCROLL:
DPRINTF_EDIT_MSG("EM_LINESCROLL");
lResult = EDIT_EM_LineScroll(wndPtr, wParam, lParam);
break;
case EM_REPLACESEL:
DPRINTF_EDIT_MSG("EM_REPLACESEL");
lResult = EDIT_EM_ReplaceSel(wndPtr, wParam, lParam);
break;
case EM_SCROLL:
DPRINTF_EDIT_MSG("EM_SCROLL");
lResult = EDIT_EM_Scroll(wndPtr, wParam, lParam);
break;
case EM_SETHANDLE:
DPRINTF_EDIT_MSG("EM_SETHANDLE");
lResult = EDIT_EM_SetHandle(wndPtr, wParam, lParam);
break;
case EM_SETMODIFY:
DPRINTF_EDIT_MSG("EM_SETMODIFY");
lResult = EDIT_EM_SetModify(wndPtr, wParam, lParam);
break;
case EM_SETPASSWORDCHAR:
DPRINTF_EDIT_MSG("EM_SETPASSWORDCHAR");
lResult = EDIT_EM_SetPasswordChar(wndPtr, wParam, lParam);
break;
case EM_SETREADONLY:
DPRINTF_EDIT_MSG("EM_SETREADONLY");
lResult = EDIT_EM_SetReadOnly(wndPtr, wParam, lParam);
break;
case EM_SETRECT:
DPRINTF_EDIT_MSG("EM_SETRECT");
lResult = EDIT_EM_SetRect(wndPtr, wParam, lParam);
break;
case EM_SETRECTNP:
DPRINTF_EDIT_MSG("EM_SETRECTNP");
lResult = EDIT_EM_SetRectNP(wndPtr, wParam, lParam);
break;
case EM_SETSEL:
DPRINTF_EDIT_MSG("EM_SETSEL");
lResult = EDIT_EM_SetSel(wndPtr, wParam, lParam);
break;
case EM_SETTABSTOPS:
DPRINTF_EDIT_MSG("EM_SETTABSTOPS");
lResult = EDIT_EM_SetTabStops(wndPtr, wParam, lParam);
break;
case EM_SETWORDBREAKPROC:
DPRINTF_EDIT_MSG("EM_SETWORDBREAKPROC");
lResult = EDIT_EM_SetWordBreakProc(wndPtr, wParam, lParam);
break;
case EM_UNDO:
case WM_UNDO:
DPRINTF_EDIT_MSG("EM_UNDO / WM_UNDO");
lResult = EDIT_EM_Undo(wndPtr, wParam, lParam);
break;
case WM_GETDLGCODE:
DPRINTF_EDIT_MSG("WM_GETDLGCODE");
lResult = EDIT_WM_GetDlgCode(wndPtr, wParam, lParam);
break;
case WM_CHAR:
DPRINTF_EDIT_MSG("WM_CHAR");
lResult = EDIT_WM_Char(wndPtr, wParam, lParam);
break;
case WM_CLEAR:
DPRINTF_EDIT_MSG("WM_CLEAR");
lResult = EDIT_WM_Clear(wndPtr, wParam, lParam);
break;
case WM_COPY:
DPRINTF_EDIT_MSG("WM_COPY");
lResult = EDIT_WM_Copy(wndPtr, wParam, lParam);
break;
case WM_CREATE:
DPRINTF_EDIT_MSG("WM_CREATE");
lResult = EDIT_WM_Create(wndPtr, wParam, lParam);
break;
case WM_CUT:
DPRINTF_EDIT_MSG("WM_CUT");
lResult = EDIT_WM_Cut(wndPtr, wParam, lParam);
break;
case WM_DESTROY:
DPRINTF_EDIT_MSG("WM_DESTROY");
lResult = EDIT_WM_Destroy(wndPtr, wParam, lParam);
break;
case WM_ENABLE:
DPRINTF_EDIT_MSG("WM_ENABLE");
lResult = EDIT_WM_Enable(wndPtr, wParam, lParam);
break;
case WM_ERASEBKGND:
DPRINTF_EDIT_MSG("WM_ERASEBKGND");
lResult = EDIT_WM_EraseBkGnd(wndPtr, wParam, lParam);
break;
case WM_GETFONT:
DPRINTF_EDIT_MSG("WM_GETFONT");
lResult = EDIT_WM_GetFont(wndPtr, wParam, lParam);
break;
case WM_GETTEXT:
DPRINTF_EDIT_MSG("WM_GETTEXT");
lResult = EDIT_WM_GetText(wndPtr, wParam, lParam);
break;
case WM_GETTEXTLENGTH:
DPRINTF_EDIT_MSG("WM_GETTEXTLENGTH");
lResult = EDIT_WM_GetTextLength(wndPtr, wParam, lParam);
break;
case WM_HSCROLL:
DPRINTF_EDIT_MSG("WM_HSCROLL");
lResult = EDIT_WM_HScroll(wndPtr, wParam, lParam);
break;
case WM_KEYDOWN:
DPRINTF_EDIT_MSG("WM_KEYDOWN");
lResult = EDIT_WM_KeyDown(wndPtr, wParam, lParam);
break;
case WM_KILLFOCUS:
DPRINTF_EDIT_MSG("WM_KILLFOCUS");
lResult = EDIT_WM_KillFocus(wndPtr, wParam, lParam);
break;
case WM_LBUTTONDBLCLK:
DPRINTF_EDIT_MSG("WM_LBUTTONDBLCLK");
lResult = EDIT_WM_LButtonDblClk(wndPtr, wParam, lParam);
break;
case WM_LBUTTONDOWN:
DPRINTF_EDIT_MSG("WM_LBUTTONDOWN");
lResult = EDIT_WM_LButtonDown(wndPtr, wParam, lParam);
break;
case WM_LBUTTONUP:
DPRINTF_EDIT_MSG("WM_LBUTTONUP");
lResult = EDIT_WM_LButtonUp(wndPtr, wParam, lParam);
break;
case WM_MOUSEMOVE:
/*
* DPRINTF_EDIT_MSG("WM_MOUSEMOVE");
*/
lResult = EDIT_WM_MouseMove(wndPtr, wParam, lParam);
break;
case WM_PAINT:
DPRINTF_EDIT_MSG("WM_PAINT");
lResult = EDIT_WM_Paint(wndPtr, wParam, lParam);
break;
case WM_PASTE:
DPRINTF_EDIT_MSG("WM_PASTE");
lResult = EDIT_WM_Paste(wndPtr, wParam, lParam);
break;
case WM_SETCURSOR:
/*
* DPRINTF_EDIT_MSG("WM_SETCURSOR");
*/
lResult = EDIT_WM_SetCursor(wndPtr, wParam, lParam);
break;
case WM_SETFOCUS:
DPRINTF_EDIT_MSG("WM_SETFOCUS");
lResult = EDIT_WM_SetFocus(wndPtr, wParam, lParam);
break;
case WM_SETFONT:
DPRINTF_EDIT_MSG("WM_SETFONT");
lResult = EDIT_WM_SetFont(wndPtr, wParam, lParam);
break;
case WM_SETREDRAW:
DPRINTF_EDIT_MSG("WM_SETREDRAW");
lResult = EDIT_WM_SetRedraw(wndPtr, wParam, lParam);
break;
case WM_SETTEXT:
DPRINTF_EDIT_MSG("WM_SETTEXT");
lResult = EDIT_WM_SetText(wndPtr, wParam, lParam);
break;
case WM_SIZE:
DPRINTF_EDIT_MSG("WM_SIZE");
lResult = EDIT_WM_Size(wndPtr, wParam, lParam);
break;
case WM_VSCROLL:
DPRINTF_EDIT_MSG("WM_VSCROLL");
lResult = EDIT_WM_VScroll(wndPtr, wParam, lParam);
break;
default:
if (msg >= WM_USER)
fprintf(stdnimp, "edit: undocumented message %d >= WM_USER, please report.\n", msg);
lResult = DefWindowProc(hwnd, msg, wParam, lParam);
break;
}
EDIT_ReleasePointer(wndPtr);
return lResult;
}
/*********************************************************************
*
* EDIT_BuildLineDefs
*
* Build array of pointers to text lines.
* Lines can end with '\0' (last line), nothing (if it is to long),
* a delimiter (usually ' '), a soft return '\r\r\n' or a hard return '\r\n'
*
*/
static void EDIT_BuildLineDefs(WND *wndPtr)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
char *text = EDIT_GetPointer(wndPtr);
int ww = EDIT_GetWndWidth(wndPtr);
HDC hdc;
HFONT hFont;
HFONT oldFont = 0;
char *start, *cp;
int prev, next;
int width;
int length;
LINE_END ending;
hdc = GetDC(wndPtr->hwndSelf);
hFont = (HFONT)EDIT_WM_GetFont(wndPtr, 0, 0L);
if (hFont)
oldFont = SelectObject(hdc, hFont);
if (!IsMultiLine(wndPtr)) {
es->LineCount = 1;
es->LineDefs = xrealloc(es->LineDefs, sizeof(LINEDEF));
es->LineDefs[0].offset = 0;
es->LineDefs[0].length = EDIT_WM_GetTextLength(wndPtr, 0, 0L);
es->LineDefs[0].ending = END_0;
es->TextWidth = LOWORD(GetTabbedTextExtent(hdc, text,
es->LineDefs[0].length,
es->NumTabStops, es->TabStops));
} else {
es->LineCount = 0;
start = text;
do {
if (!(cp = strstr(start, "\r\n"))) {
ending = END_0;
length = strlen(start);
} else if ((cp > start) && (*(cp - 1) == '\r')) {
ending = END_SOFT;
length = cp - start - 1;
} else {
ending = END_HARD;
length = cp - start;
}
width = LOWORD(GetTabbedTextExtent(hdc, start, length,
es->NumTabStops, es->TabStops));
if (IsWordWrap(wndPtr) && (width > ww)) {
next = 0;
do {
prev = next;
next = EDIT_CallWordBreakProc(wndPtr, start,
prev + 1, length, WB_RIGHT);
width = LOWORD(GetTabbedTextExtent(hdc, start, next,
es->NumTabStops, es->TabStops));
} while (width <= ww);
if (prev) {
length = prev;
if (EDIT_CallWordBreakProc(wndPtr, start, length - 1,
length, WB_ISDELIMITER)) {
length--;
ending = END_DELIMIT;
} else
ending = END_NONE;
} else {
}
width = LOWORD(GetTabbedTextExtent(hdc, start, length,
es->NumTabStops, es->TabStops));
}
es->LineDefs = xrealloc(es->LineDefs, (es->LineCount + 1) * sizeof(LINEDEF));
es->LineDefs[es->LineCount].offset = start - text;
es->LineDefs[es->LineCount].length = length;
es->LineDefs[es->LineCount].ending = ending;
es->LineCount++;
es->TextWidth = MAX(es->TextWidth, width);
start += length;
switch (ending) {
case END_SOFT:
start += 3;
break;
case END_HARD:
start += 2;
break;
case END_DELIMIT:
start++;
break;
default:
break;
}
} while (*start || (ending == END_SOFT) || (ending == END_HARD));
}
if (hFont)
SelectObject(hdc, oldFont);
ReleaseDC(wndPtr->hwndSelf, hdc);
}
/*********************************************************************
*
* EDIT_CallWordBreakProc
*
* Call appropriate WordBreakProc (internal or external).
*
*/
static int EDIT_CallWordBreakProc(WND *wndPtr, char *s, int index, int count, int action)
{
EDITWORDBREAKPROC wbp = (EDITWORDBREAKPROC)EDIT_EM_GetWordBreakProc(wndPtr, 0, 0L);
if (wbp) {
return CallWordBreakProc((FARPROC)wbp,
(LONG)MAKE_SEGPTR(s), index, count, action);
} else
return EDIT_WordBreakProc(s, index, count, action);
}
/*********************************************************************
*
* EDIT_ColFromWndX
*
* Calculates, for a given line and X-coordinate on the screen, the column.
*
*/
static int EDIT_ColFromWndX(WND *wndPtr, int line, int x)
{
int linecount = EDIT_EM_GetLineCount(wndPtr, 0, 0L);
int lineindex = EDIT_EM_LineIndex(wndPtr, line, 0L);
int linelength = EDIT_EM_LineLength(wndPtr, lineindex, 0L);
int i;
line = MAX(0, MIN(line, linecount - 1));
for (i = 0 ; i < linelength ; i++)
if (EDIT_WndXFromCol(wndPtr, line, i) >= x)
break;
return i;
}
/*********************************************************************
*
* EDIT_DelEnd
*
* Delete all characters on this line to right of cursor.
*
*/
static void EDIT_DelEnd(WND *wndPtr)
{
EDIT_EM_SetSel(wndPtr, FALSE, MAKELPARAM(-1, 0));
EDIT_MoveEnd(wndPtr, TRUE);
EDIT_WM_Clear(wndPtr, 0, 0L);
}
/*********************************************************************
*
* EDIT_DelLeft
*
* Delete character to left of cursor.
*
*/
static void EDIT_DelLeft(WND *wndPtr)
{
EDIT_EM_SetSel(wndPtr, FALSE, MAKELPARAM(-1, 0));
EDIT_MoveBackward(wndPtr, TRUE);
EDIT_WM_Clear(wndPtr, 0, 0L);
}
/*********************************************************************
*
* EDIT_DelRight
*
* Delete character to right of cursor.
*
*/
static void EDIT_DelRight(WND *wndPtr)
{
EDIT_EM_SetSel(wndPtr, FALSE, MAKELPARAM(-1, 0));
EDIT_MoveForward(wndPtr, TRUE);
EDIT_WM_Clear(wndPtr, 0, 0L);
}
/*********************************************************************
*
* EDIT_GetAveCharWidth
*
*/
static int EDIT_GetAveCharWidth(WND *wndPtr)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
return es->AveCharWidth;
}
/*********************************************************************
*
* EDIT_GetLineHeight
*
*/
static int EDIT_GetLineHeight(WND *wndPtr)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
return es->LineHeight;
}
/*********************************************************************
*
* EDIT_GetLineRect
*
* Calculates the bounding rectangle for a line from a starting
* column to an ending column.
*
*/
static void EDIT_GetLineRect(WND *wndPtr, int line, int scol, int ecol, LPRECT rc)
{
rc->top = EDIT_WndYFromLine(wndPtr, line);
rc->bottom = rc->top + EDIT_GetLineHeight(wndPtr);
rc->left = EDIT_WndXFromCol(wndPtr, line, scol);
rc->right = (ecol < 0) ? EDIT_GetWndWidth(wndPtr) : EDIT_WndXFromCol(wndPtr, line, ecol);
}
/*********************************************************************
*
* EDIT_GetPointer
*
* This acts as a LOCAL_Lock(), but it locks only once. This way
* you can call it whenever you like, without unlocking.
*
*/
static char *EDIT_GetPointer(WND *wndPtr)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
if (!es->text && es->hBuf)
es->text = LOCAL_Lock(wndPtr->hInstance, es->hBuf);
return es->text;
}
/*********************************************************************
*
* EDIT_GetRect
*
* Beware: This is not the function called on EM_GETRECT.
* It expects a (LPRECT) in lParam, not a (SEGPTR).
* It is used internally, as if there were no pointer difficulties.
*
*/
static LRESULT EDIT_GetRect(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
GetClientRect(wndPtr->hwndSelf, (LPRECT)lParam);
return 0L;
}
/*********************************************************************
*
* EDIT_GetRedraw
*
*/
static BOOL EDIT_GetRedraw(WND *wndPtr)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
return es->Redraw;
}
/*********************************************************************
*
* EDIT_GetTextWidth
*
*/
static int EDIT_GetTextWidth(WND *wndPtr)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
return es->TextWidth;
}
/*********************************************************************
*
* EDIT_GetVisibleLineCount
*
*/
static int EDIT_GetVisibleLineCount(WND *wndPtr)
{
RECT rc;
EDIT_GetRect(wndPtr, 0, (LPARAM)&rc);
return MAX(1, MAX(rc.bottom - rc.top, 0) / EDIT_GetLineHeight(wndPtr));
}
/*********************************************************************
*
* EDIT_GetWndWidth
*
*/
static int EDIT_GetWndWidth(WND *wndPtr)
{
RECT rc;
EDIT_GetRect(wndPtr, 0, (LPARAM)&rc);
return rc.right - rc.left;
}
/*********************************************************************
*
* EDIT_GetXOffset
*
*/
static int EDIT_GetXOffset(WND *wndPtr)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
return es->XOffset;
}
/*********************************************************************
*
* EDIT_LineFromWndY
*
* Calculates, for a given Y-coordinate on the screen, the line.
*
*/
static int EDIT_LineFromWndY(WND *wndPtr, int y)
{
int firstvis = EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0L);
int lineheight = EDIT_GetLineHeight(wndPtr);
int linecount = EDIT_EM_GetLineCount(wndPtr, 0, 0L);
return MAX(0, MIN(linecount - 1, y / lineheight + firstvis));
}
/*********************************************************************
*
* EDIT_MakeFit
*
* Try to fit size + 1 bytes in the buffer. Contrain to limits.
*
*/
static BOOL EDIT_MakeFit(WND *wndPtr, int size)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
if (size <= es->BufSize)
return TRUE;
if (size > es->BufLimit)
return FALSE;
es->BufSize = ((size / GROWLENGTH) + 1) * GROWLENGTH;
if (es->BufSize > es->BufLimit)
es->BufSize = es->BufLimit;
dprintf_edit(stddeb, "edit: EDIT_MakeFit: ReAlloc to %d+1\n", es->BufSize);
return LOCAL_ReAlloc(wndPtr->hInstance, es->hBuf, es->BufSize + 1, LMEM_MOVEABLE);
}
/*********************************************************************
*
* EDIT_MoveBackward
*
*/
static void EDIT_MoveBackward(WND *wndPtr, BOOL extend)
{
int s = LOWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int e = HIWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int l = EDIT_EM_LineFromChar(wndPtr, e, 0L);
int lineindex = EDIT_EM_LineIndex(wndPtr, l, 0L);
if (e - lineindex == 0) {
if (l) {
lineindex = EDIT_EM_LineIndex(wndPtr, l - 1, 0L);
e = lineindex + EDIT_EM_LineLength(wndPtr, lineindex, 0L);
}
} else
e--;
if (!extend)
s = e;
EDIT_EM_SetSel(wndPtr, TRUE, MAKELPARAM(s, e));
}
/*********************************************************************
*
* EDIT_MoveDownward
*
*/
static void EDIT_MoveDownward(WND *wndPtr, BOOL extend)
{
int s = LOWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int e = HIWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int l = EDIT_EM_LineFromChar(wndPtr, e, 0L);
int linecount = EDIT_EM_GetLineCount(wndPtr, e, 0L);
int lineindex = EDIT_EM_LineIndex(wndPtr, l, 0L);
int x;
if (l < linecount - 1) {
x = EDIT_WndXFromCol(wndPtr, l, e - lineindex);
l++;
e = EDIT_EM_LineIndex(wndPtr, l, 0L) +
EDIT_ColFromWndX(wndPtr, l, x);
}
if (!extend)
s = e;
EDIT_EM_SetSel(wndPtr, TRUE, MAKELPARAM(s, e));
}
/*********************************************************************
*
* EDIT_MoveEnd
*
*/
static void EDIT_MoveEnd(WND *wndPtr, BOOL extend)
{
int s = LOWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int e = HIWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int l = EDIT_EM_LineFromChar(wndPtr, e, 0L);
int linelength = EDIT_EM_LineLength(wndPtr, e, 0L);
int lineindex = EDIT_EM_LineIndex(wndPtr, l, 0L);
e = lineindex + linelength;
if (!extend)
s = e;
EDIT_EM_SetSel(wndPtr, TRUE, MAKELPARAM(s, e));
}
/*********************************************************************
*
* EDIT_MoveForward
*
*/
static void EDIT_MoveForward(WND *wndPtr, BOOL extend)
{
int s = LOWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int e = HIWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int l = EDIT_EM_LineFromChar(wndPtr, e, 0L);
int linecount = EDIT_EM_GetLineCount(wndPtr, e, 0L);
int linelength = EDIT_EM_LineLength(wndPtr, e, 0L);
int lineindex = EDIT_EM_LineIndex(wndPtr, l, 0L);
if (e - lineindex == linelength) {
if (l != linecount - 1)
e = EDIT_EM_LineIndex(wndPtr, l + 1, 0L);
} else
e++;
if (!extend)
s = e;
EDIT_EM_SetSel(wndPtr, TRUE, MAKELPARAM(s, e));
}
/*********************************************************************
*
* EDIT_MoveHome
*
* Home key: move to beginning of line.
*
*/
static void EDIT_MoveHome(WND *wndPtr, BOOL extend)
{
int s = LOWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int e = HIWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int l = EDIT_EM_LineFromChar(wndPtr, e, 0L);
int lineindex = EDIT_EM_LineIndex(wndPtr, l, 0L);
e = lineindex;
if (!extend)
s = e;
EDIT_EM_SetSel(wndPtr, TRUE, MAKELPARAM(s, e));
}
/*********************************************************************
*
* EDIT_MovePageDown
*
*/
static void EDIT_MovePageDown(WND *wndPtr, BOOL extend)
{
int s = LOWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int e = HIWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int l = EDIT_EM_LineFromChar(wndPtr, e, 0L);
int linecount = EDIT_EM_GetLineCount(wndPtr, e, 0L);
int lineindex = EDIT_EM_LineIndex(wndPtr, l, 0L);
int x;
if (l < linecount - 1) {
x = EDIT_WndXFromCol(wndPtr, l, e - lineindex);
l = MIN(linecount - 1, l + EDIT_GetVisibleLineCount(wndPtr));
e = EDIT_EM_LineIndex(wndPtr, l, 0L) +
EDIT_ColFromWndX(wndPtr, l, x);
}
if (!extend)
s = e;
EDIT_EM_SetSel(wndPtr, TRUE, MAKELPARAM(s, e));
}
/*********************************************************************
*
* EDIT_MovePageUp
*
*/
static void EDIT_MovePageUp(WND *wndPtr, BOOL extend)
{
int s = LOWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int e = HIWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int l = EDIT_EM_LineFromChar(wndPtr, e, 0L);
int lineindex = EDIT_EM_LineIndex(wndPtr, l, 0L);
int x;
if (l) {
x = EDIT_WndXFromCol(wndPtr, l, e - lineindex);
l = MAX(0, l - EDIT_GetVisibleLineCount(wndPtr));
e = EDIT_EM_LineIndex(wndPtr, l, 0L) +
EDIT_ColFromWndX(wndPtr, l, x);
}
if (!extend)
s = e;
EDIT_EM_SetSel(wndPtr, TRUE, MAKELPARAM(s, e));
}
/*********************************************************************
*
* EDIT_MoveUpward
*
*/
static void EDIT_MoveUpward(WND *wndPtr, BOOL extend)
{
int s = LOWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int e = HIWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int l = EDIT_EM_LineFromChar(wndPtr, e, 0L);
int lineindex = EDIT_EM_LineIndex(wndPtr, l, 0L);
int x;
if (l) {
x = EDIT_WndXFromCol(wndPtr, l, e - lineindex);
l--;
e = EDIT_EM_LineIndex(wndPtr, l, 0L) +
EDIT_ColFromWndX(wndPtr, l, x);
}
if (!extend)
s = e;
EDIT_EM_SetSel(wndPtr, TRUE, MAKELPARAM(s, e));
}
/*********************************************************************
*
* EDIT_MoveWordBackward
*
*/
static void EDIT_MoveWordBackward(WND *wndPtr, BOOL extend)
{
int s = LOWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int e = HIWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int l = EDIT_EM_LineFromChar(wndPtr, e, 0L);
int linelength = EDIT_EM_LineLength(wndPtr, e, 0L);
int lineindex = EDIT_EM_LineIndex(wndPtr, l, 0L);
char *text;
if (e - lineindex == 0) {
if (l) {
lineindex = EDIT_EM_LineIndex(wndPtr, l - 1, 0L);
e = lineindex + EDIT_EM_LineLength(wndPtr, lineindex, 0L);
}
} else {
text = EDIT_GetPointer(wndPtr);
e = lineindex + EDIT_CallWordBreakProc(wndPtr, text + lineindex,
e - lineindex, linelength, WB_LEFT);
}
if (!extend)
s = e;
EDIT_EM_SetSel(wndPtr, TRUE, MAKELPARAM(s, e));
}
/*********************************************************************
*
* EDIT_MoveWordForward
*
*/
static void EDIT_MoveWordForward(WND *wndPtr, BOOL extend)
{
int s = LOWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int e = HIWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int l = EDIT_EM_LineFromChar(wndPtr, e, 0L);
int linecount = EDIT_EM_GetLineCount(wndPtr, e, 0L);
int linelength = EDIT_EM_LineLength(wndPtr, e, 0L);
int lineindex = EDIT_EM_LineIndex(wndPtr, l, 0L);
char *text;
if (e - lineindex == linelength) {
if (l != linecount - 1)
e = EDIT_EM_LineIndex(wndPtr, l + 1, 0L);
} else {
text = EDIT_GetPointer(wndPtr);
e = lineindex + EDIT_CallWordBreakProc(wndPtr, text + lineindex,
e - lineindex + 1, linelength, WB_RIGHT);
}
if (!extend)
s = e;
EDIT_EM_SetSel(wndPtr, TRUE, MAKELPARAM(s, e));
}
/*********************************************************************
*
* EDIT_PaintLine
*
*/
static void EDIT_PaintLine(WND *wndPtr, HDC hdc, int line)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
int firstvis = EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0L);
int viscount = EDIT_GetVisibleLineCount(wndPtr);
int linecount = EDIT_EM_GetLineCount(wndPtr, 0, 0L);
int LineStart;
int LineEnd;
int ReverseStart;
int ReverseEnd;
int x;
int y;
if ((line < firstvis) || (line > firstvis + viscount) || (line >= linecount))
return;
dprintf_edit(stddeb, "edit: EDIT_PaintLine: line=%d\n", line);
x = EDIT_WndXFromCol(wndPtr, line, 0);
y = EDIT_WndYFromLine(wndPtr, line);
LineStart = EDIT_EM_LineIndex(wndPtr, line, 0L);
LineEnd = LineStart + EDIT_EM_LineLength(wndPtr, LineStart, 0L);
ReverseStart = MIN(es->SelStart, es->SelEnd);
ReverseEnd = MAX(es->SelStart, es->SelEnd);
ReverseStart = MIN(LineEnd, MAX(LineStart, ReverseStart));
ReverseEnd = MIN(LineEnd, MAX(LineStart, ReverseEnd));
if (ReverseStart != ReverseEnd) {
x += EDIT_PaintText(wndPtr, hdc, x, y, line,
0, ReverseStart - LineStart, FALSE);
x += EDIT_PaintText(wndPtr, hdc, x, y, line,
ReverseStart - LineStart,
ReverseEnd - ReverseStart, TRUE);
x += EDIT_PaintText(wndPtr, hdc, x, y, line,
ReverseEnd - LineStart,
LineEnd - ReverseEnd, FALSE);
} else
x += EDIT_PaintText(wndPtr, hdc, x, y, line,
0, LineEnd - LineStart, FALSE);
}
/*********************************************************************
*
* EDIT_PaintText
*
*/
static int EDIT_PaintText(WND *wndPtr, HDC hdc, int x, int y, int line, int col, int count, BOOL rev)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
COLORREF BkColor;
COLORREF TextColor;
int ret;
char *text;
int lineindex = EDIT_EM_LineIndex(wndPtr, line, 0L);
int xoffset = EDIT_GetXOffset(wndPtr);
if (count < 1)
return 0;
BkColor = GetBkColor(hdc);
TextColor = GetTextColor(hdc);
if (rev) {
SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
}
text = EDIT_GetPointer(wndPtr);
ret = LOWORD(TabbedTextOut(hdc, x, y, text + lineindex + col, count,
es->NumTabStops, es->TabStops, -xoffset));
if (rev) {
SetBkColor(hdc, BkColor);
SetTextColor(hdc, TextColor);
}
return ret;
}
/*********************************************************************
*
* EDIT_ReleasePointer
*
* This is the only helper function that can be called with es = NULL.
* It is called at the end of EditWndProc() to unlock the buffer.
*
*/
static void EDIT_ReleasePointer(WND *wndPtr)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
if (!es)
return;
if (es->text && es->hBuf)
LOCAL_Unlock(wndPtr->hInstance, es->hBuf);
es->text = NULL;
}
/*********************************************************************
*
* EDIT_ReplaceSel
*
* Beware: This is not the function called on EM_REPLACESEL.
* It expects a (char *) in lParam, not a (SEGPTR).
* It is used internally, as if there were no pointer difficulties.
*
*/
static LRESULT EDIT_ReplaceSel(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
const char *str = (char *)lParam;
int strl = strlen(str);
int tl = EDIT_WM_GetTextLength(wndPtr, 0, 0L);
int s = LOWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int e = HIWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int i;
char *p;
char *text;
BOOL redraw;
ORDER_INT(s,e);
if (!EDIT_MakeFit(wndPtr, tl - (e - s) + strl)) {
EDIT_NOTIFY_PARENT(wndPtr, EN_MAXTEXT);
return 0L;
}
redraw = EDIT_GetRedraw(wndPtr);
EDIT_WM_SetRedraw(wndPtr, FALSE, 0L);
EDIT_WM_Clear(wndPtr, 0, 0L);
tl = EDIT_WM_GetTextLength(wndPtr, 0, 0L);
e = HIWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
text = EDIT_GetPointer(wndPtr);
for (p = text + tl ; p >= text + e ; p--)
p[strl] = p[0];
for (i = 0 , p = text + e ; i < strl ; i++)
p[i] = str[i];
EDIT_BuildLineDefs(wndPtr);
e += strl;
EDIT_EM_SetSel(wndPtr, TRUE, MAKELPARAM(e, e));
EDIT_EM_SetModify(wndPtr, TRUE, 0L);
EDIT_NOTIFY_PARENT(wndPtr, EN_UPDATE);
EDIT_WM_SetRedraw(wndPtr, redraw, 0L);
if (redraw) {
InvalidateRect(wndPtr->hwndSelf, NULL, TRUE);
EDIT_NOTIFY_PARENT(wndPtr, EN_CHANGE);
}
return 0L;
}
/*********************************************************************
*
* EDIT_ScrollIntoView
*
* Makes sure the caret is visible.
*
*/
static void EDIT_ScrollIntoView(WND *wndPtr)
{
int e = HIWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int l = EDIT_EM_LineFromChar(wndPtr, e, 0L);
int lineindex = EDIT_EM_LineIndex(wndPtr, l, 0L);
int firstvis = EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0L);
int vislinecount = EDIT_GetVisibleLineCount(wndPtr);
int wndwidth = EDIT_GetWndWidth(wndPtr);
int charwidth = EDIT_GetAveCharWidth(wndPtr);
int x = EDIT_WndXFromCol(wndPtr, l, e - lineindex);
int dy = 0;
int dx = 0;
if (l >= firstvis + vislinecount)
dy = l - vislinecount + 1 - firstvis;
if (l < firstvis)
dy = l - firstvis;
if (x < 0)
dx = x - wndwidth / HSCROLL_FRACTION / charwidth * charwidth;
if (x > wndwidth)
dx = x - (HSCROLL_FRACTION - 1) * wndwidth / HSCROLL_FRACTION / charwidth * charwidth;
if (dy || dx) {
EDIT_EM_LineScroll(wndPtr, 0, MAKELPARAM(dy, dx));
if (dy)
EDIT_NOTIFY_PARENT(wndPtr, EN_VSCROLL);
if (dx)
EDIT_NOTIFY_PARENT(wndPtr, EN_HSCROLL);
}
}
/*********************************************************************
*
* EDIT_WndXFromCol
*
* Calculates, for a given line and column, the X-coordinate on the screen.
*
*/
static int EDIT_WndXFromCol(WND *wndPtr, int line, int col)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
char *text = EDIT_GetPointer(wndPtr);
int ret;
HDC hdc;
HFONT hFont;
HFONT oldFont = 0;
int linecount = EDIT_EM_GetLineCount(wndPtr, 0, 0L);
int lineindex = EDIT_EM_LineIndex(wndPtr, line, 0L);
int linelength = EDIT_EM_LineLength(wndPtr, lineindex, 0L);
int xoffset = EDIT_GetXOffset(wndPtr);
hdc = GetDC(wndPtr->hwndSelf);
hFont = (HFONT)EDIT_WM_GetFont(wndPtr, 0, 0L);
if (hFont)
oldFont = SelectObject(hdc, hFont);
line = MAX(0, MIN(line, linecount - 1));
col = MAX(0, MIN(col, linelength));
ret = LOWORD(GetTabbedTextExtent(hdc,
text + lineindex, col,
es->NumTabStops, es->TabStops)) - xoffset;
if (hFont)
SelectObject(hdc, oldFont);
ReleaseDC(wndPtr->hwndSelf, hdc);
return ret;
}
/*********************************************************************
*
* EDIT_WndYFromLine
*
* Calculates, for a given line, the Y-coordinate on the screen.
*
*/
static int EDIT_WndYFromLine(WND *wndPtr, int line)
{
int firstvis = EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0L);
int lineheight = EDIT_GetLineHeight(wndPtr);
return (line - firstvis) * lineheight;
}
/*********************************************************************
*
* EDIT_WordBreakProc
*
* Find the beginning of words.
* Note: unlike the specs for a WordBreakProc, this function only
* allows to be called without linebreaks between s[0] upto
* s[count - 1]. Remember it is only called
* internally, so we can decide this for ourselves.
*
*/
static int EDIT_WordBreakProc(char *s, int index, int count, int action)
{
int ret = 0;
dprintf_edit(stddeb, "edit: EDIT_WordBreakProc: s=%p, index=%d"
", count=%d, action=%d\n", s, index, count, action);
switch (action) {
case WB_LEFT:
if (!count)
break;
if (index)
index--;
if (s[index] == ' ') {
while (index && (s[index] == ' '))
index--;
if (index) {
while (index && (s[index] != ' '))
index--;
if (s[index] == ' ')
index++;
}
} else {
while (index && (s[index] != ' '))
index--;
if (s[index] == ' ')
index++;
}
ret = index;
break;
case WB_RIGHT:
if (!count)
break;
if (index)
index--;
if (s[index] == ' ')
while ((index < count) && (s[index] == ' ')) index++;
else {
while (s[index] && (s[index] != ' ') && (index < count))
index++;
while ((s[index] == ' ') && (index < count)) index++;
}
ret = index;
break;
case WB_ISDELIMITER:
ret = (s[index] == ' ');
break;
default:
fprintf(stderr, "edit: EDIT_WordBreakProc: unknown action code, please report !\n");
break;
}
return ret;
}
/*********************************************************************
*
* EM_CANUNDO
*
*/
static LRESULT EDIT_EM_CanUndo(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
return 0L;
}
/*********************************************************************
*
* EM_EMPTYUNDOBUFFER
*
*/
static LRESULT EDIT_EM_EmptyUndoBuffer(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
return 0L;
}
/*********************************************************************
*
* EM_FMTLINES
*
*/
static LRESULT EDIT_EM_FmtLines(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
fprintf(stdnimp, "edit: EM_FMTLINES: message not implemented.\n");
return wParam ? -1L : 0L;
}
/*********************************************************************
*
* EM_GETFIRSTVISIBLELINE
*
*/
static LRESULT EDIT_EM_GetFirstVisibleLine(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
return (LRESULT)es->FirstVisibleLine;
}
/*********************************************************************
*
* EM_GETHANDLE
*
*/
static LRESULT EDIT_EM_GetHandle(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
return (LRESULT)es->hBuf;
}
/*********************************************************************
*
* EM_GETLINE
*
*/
static LRESULT EDIT_EM_GetLine(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
char *text;
char *src;
char *dst;
int len;
int i;
int linecount = EDIT_EM_GetLineCount(wndPtr, 0, 0L);
if (!IsMultiLine(wndPtr))
wParam = 0;
if ((UINT)wParam >= linecount)
return 0L;
text = EDIT_GetPointer(wndPtr);
src = text + EDIT_EM_LineIndex(wndPtr, wParam, 0L);
dst = (char *)PTR_SEG_TO_LIN(lParam);
len = MIN(*(WORD *)dst, EDIT_EM_LineLength(wndPtr, wParam, 0L));
for (i = 0 ; i < len ; i++) {
*dst = *src;
src++;
dst++;
}
return (LRESULT)len;
}
/*********************************************************************
*
* EM_GETLINECOUNT
*
*/
static LRESULT EDIT_EM_GetLineCount(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
return (LRESULT)es->LineCount;
}
/*********************************************************************
*
* EM_GETMODIFY
*
*/
static LRESULT EDIT_EM_GetModify(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
return (LRESULT)es->TextChanged;
}
/*********************************************************************
*
* EM_GETPASSWORDCHAR
*
*/
static LRESULT EDIT_EM_GetPasswordChar(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
return (LRESULT)es->PasswordChar;
}
/*********************************************************************
*
* EM_GETRECT
*
*/
static LRESULT EDIT_EM_GetRect(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
return EDIT_GetRect(wndPtr, wParam, (LPARAM)PTR_SEG_TO_LIN(lParam));
}
/*********************************************************************
*
* EM_GETSEL
*
*/
static LRESULT EDIT_EM_GetSel(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
return MAKELONG(es->SelStart, es->SelEnd);
}
/*********************************************************************
*
* EM_GETTHUMB
*
* undocumented: is this right ?
*
*/
static LRESULT EDIT_EM_GetThumb(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
return MAKELONG(EDIT_WM_VScroll(wndPtr, EM_GETTHUMB, 0L),
EDIT_WM_HScroll(wndPtr, EM_GETTHUMB, 0L));
}
/*********************************************************************
*
* EM_GETWORDBREAKPROC
*
*/
static LRESULT EDIT_EM_GetWordBreakProc(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
return (LRESULT)es->WordBreakProc;
}
/*********************************************************************
*
* EM_LIMITTEXT
*
*/
static LRESULT EDIT_EM_LimitText(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
if (IsMultiLine(wndPtr)) {
if (wParam)
es->BufLimit = MIN((UINT)wParam, BUFLIMIT_MULTI);
else
es->BufLimit = BUFLIMIT_MULTI;
} else {
if (wParam)
es->BufLimit = MIN((UINT)wParam, BUFLIMIT_SINGLE);
else
es->BufLimit = BUFLIMIT_SINGLE;
}
return 0L;
}
/*********************************************************************
*
* EM_LINEFROMCHAR
*
*/
static LRESULT EDIT_EM_LineFromChar(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
int l;
if (!IsMultiLine(wndPtr))
return 0L;
if ((INT)wParam == -1)
wParam = HIWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
l = EDIT_EM_GetLineCount(wndPtr, 0, 0L) - 1;
while (EDIT_EM_LineIndex(wndPtr, l, 0L) > (UINT)wParam)
l--;
return (LRESULT)l;
}
/*********************************************************************
*
* EM_LINEINDEX
*
*/
static LRESULT EDIT_EM_LineIndex(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
int e;
int l;
if ((INT)wParam < 0) {
e = HIWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
l = EDIT_EM_GetLineCount(wndPtr, 0, 0L) - 1;
while (es->LineDefs[l].offset > (UINT)wParam)
l--;
return (LRESULT)es->LineDefs[l].offset;
}
if (wParam >= es->LineCount)
return -1L;
return (LRESULT)es->LineDefs[wParam].offset;
}
/*********************************************************************
*
* EM_LINELENGTH
*
*/
static LRESULT EDIT_EM_LineLength(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
int SelStartLine;
int SelEndLine;
if (!IsMultiLine(wndPtr))
return (LRESULT)es->LineDefs[0].length;
if ((INT)wParam >= 0)
return (LRESULT)es->LineDefs[EDIT_EM_LineFromChar(wndPtr, wParam, 0L)].length;
SelStartLine = EDIT_EM_LineFromChar(wndPtr, es->SelStart, 0L);
SelEndLine = EDIT_EM_LineFromChar(wndPtr, es->SelEnd, 0L);
return (LRESULT)(es->SelStart - es->LineDefs[SelStartLine].offset +
es->LineDefs[SelEndLine].offset +
es->LineDefs[SelEndLine].length - es->SelEnd);
}
/*********************************************************************
*
* EM_LINESCROLL
*
*/
static LRESULT EDIT_EM_LineScroll(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
int linecount = EDIT_EM_GetLineCount(wndPtr, 0, 0L);
int firstvis = EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0L);
int newfirstvis = firstvis + (INT)LOWORD(lParam);
int xoffset = EDIT_GetXOffset(wndPtr);
int newxoffset = xoffset + (INT)HIWORD(lParam);
int textwidth = EDIT_GetTextWidth(wndPtr);
int dx;
int dy;
POINT pos;
HRGN hRgn;
if (newfirstvis < 0)
newfirstvis = 0;
if (newfirstvis >= linecount)
newfirstvis = linecount - 1;
if (newxoffset < 0)
newxoffset = 0;
if (newxoffset >= textwidth)
newxoffset = textwidth;
dx = xoffset - newxoffset;
dy = EDIT_WndYFromLine(wndPtr, firstvis) - EDIT_WndYFromLine(wndPtr, newfirstvis);
if (dx || dy) {
if (wndPtr->hwndSelf == GetFocus())
HideCaret(wndPtr->hwndSelf);
if (EDIT_GetRedraw(wndPtr)) {
hRgn = CreateRectRgn(0, 0, 0, 0);
GetUpdateRgn(wndPtr->hwndSelf, hRgn, FALSE);
ValidateRgn(wndPtr->hwndSelf, 0);
OffsetRgn(hRgn, dx, dy);
InvalidateRgn(wndPtr->hwndSelf, hRgn, TRUE);
DeleteObject(hRgn);
ScrollWindow(wndPtr->hwndSelf, dx, dy, NULL, NULL);
}
es->FirstVisibleLine = newfirstvis;
es->XOffset = newxoffset;
if (IsVScrollBar(wndPtr))
SetScrollPos(wndPtr->hwndSelf, SB_VERT,
EDIT_WM_VScroll(wndPtr, EM_GETTHUMB, 0L), TRUE);
if (IsHScrollBar(wndPtr))
SetScrollPos(wndPtr->hwndSelf, SB_HORZ,
EDIT_WM_HScroll(wndPtr, EM_GETTHUMB, 0L), TRUE);
if (wndPtr->hwndSelf == GetFocus()) {
GetCaretPos(&pos);
SetCaretPos(pos.x + dx, pos.y + dy);
ShowCaret(wndPtr->hwndSelf);
}
}
return -1L;
}
/*********************************************************************
*
* EM_REPLACESEL
*
*/
static LRESULT EDIT_EM_ReplaceSel(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
return (LRESULT)EDIT_ReplaceSel(wndPtr, wParam,
(LPARAM)(char *)PTR_SEG_TO_LIN(lParam));
}
/*********************************************************************
*
* EM_SCROLL
*
* FIXME: undocumented message.
*/
static LRESULT EDIT_EM_Scroll(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
fprintf(stdnimp, "edit: EM_SCROLL: message not implemented (undocumented), please report.\n");
return 0L;
}
/*********************************************************************
*
* EM_SETHANDLE
*
*/
static LRESULT EDIT_EM_SetHandle(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
if (IsMultiLine(wndPtr)) {
EDIT_ReleasePointer(wndPtr);
/*
* FIXME: specs say: old buffer should be freed
* by the aplication, but e.g. Notepad doesn't.
* Should we LOCAL_Free() the old hBuf ?
*/
LOCAL_Free(wndPtr->hInstance, es->hBuf);
es->hBuf = (HLOCAL)wParam;
es->BufSize = MIN(1, LOCAL_Size(wndPtr->hInstance, es->hBuf)) - 1;
es->hBuf = LOCAL_ReAlloc(wndPtr->hInstance, es->hBuf, es->BufSize + 1, LMEM_MOVEABLE);
es->LineCount = 0;
es->FirstVisibleLine = 0;
es->SelStart = es->SelEnd = 0;
EDIT_EM_EmptyUndoBuffer(wndPtr, 0, 0L);
EDIT_EM_SetModify(wndPtr, FALSE, 0L);
EDIT_BuildLineDefs(wndPtr);
if (EDIT_GetRedraw(wndPtr))
InvalidateRect(wndPtr->hwndSelf, NULL, TRUE);
}
return 0L;
}
/*********************************************************************
*
* EM_SETMODIFY
*
*/
static LRESULT EDIT_EM_SetModify(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
es->TextChanged = wParam;
return 0L;
}
/*********************************************************************
*
* EM_SETPASSWORDCHAR
*
*/
static LRESULT EDIT_EM_SetPasswordChar(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
es->PasswordChar = (char)wParam;
return 0L;
}
/*********************************************************************
*
* EM_SETREADONLY
*
*/
static LRESULT EDIT_EM_SetReadOnly(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
if ((BOOL)wParam)
wndPtr->dwStyle |= ES_READONLY;
else
wndPtr->dwStyle &= ~(DWORD)ES_READONLY;
return 0L;
}
/*********************************************************************
*
* EM_SETRECT
*
*/
static LRESULT EDIT_EM_SetRect(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
fprintf(stdnimp,"edit: EM_SETRECT: message not implemented, please report.\n");
return 0L;
}
/*********************************************************************
*
* EM_SETRECTNP
*
*/
static LRESULT EDIT_EM_SetRectNP(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
fprintf(stdnimp,"edit: EM_SETRECTNP: message not implemented, please report.\n");
return 0L;
}
/*********************************************************************
*
* EM_SETSEL
*
*/
static LRESULT EDIT_EM_SetSel(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
int ns = (INT)LOWORD(lParam);
int ne = (INT)HIWORD(lParam);
int s = LOWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int e = HIWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int sl;
int el;
int sc;
int ec;
int elineindex;
int tl = EDIT_WM_GetTextLength(wndPtr, 0, 0L);
RECT rc;
HRGN hRgn1, hRgn2;
HRGN oldRgn, newRgn;
if (ns < 0) {
ne = e;
ns = e;
} else {
ns = MIN(ns, tl);
if (ne < 0)
ne = tl;
ne = MIN(ne, tl);
}
es->SelStart = ns;
es->SelEnd = ne;
if (wndPtr->hwndSelf == GetFocus()) {
el = EDIT_EM_LineFromChar(wndPtr, ne, 0L);
elineindex = EDIT_EM_LineIndex(wndPtr, el, 0L);
SetCaretPos(EDIT_WndXFromCol(wndPtr, el, ne - elineindex),
EDIT_WndYFromLine(wndPtr, el));
}
if (wParam)
EDIT_ScrollIntoView(wndPtr);
/*
* Let's do some repainting
*/
ORDER_INT(s, e);
ORDER_INT(ns, ne);
if (EDIT_GetRedraw(wndPtr) &&
!(((s == e) && (ns == ne)) ||
((ns == s) && (ne == e)))) {
/* Yes, there is something to paint */
hRgn1 = CreateRectRgn(0, 0, 0, 0);
hRgn2 = CreateRectRgn(0, 0, 0, 0);
oldRgn = CreateRectRgn(0, 0, 0, 0);
newRgn = CreateRectRgn(0, 0, 0, 0);
/* Build the old selection region */
sl = EDIT_EM_LineFromChar(wndPtr, s, 0L);
el = EDIT_EM_LineFromChar(wndPtr, e, 0L);
sc = s - EDIT_EM_LineIndex(wndPtr, sl, 0L);
ec = e - EDIT_EM_LineIndex(wndPtr, el, 0L);
if (sl == el) {
EDIT_GetLineRect(wndPtr, sl, sc, ec, &rc);
SetRectRgn(oldRgn, rc.left, rc.top, rc.right, rc.bottom);
} else {
EDIT_GetLineRect(wndPtr, sl, sc, -1, &rc);
SetRectRgn(hRgn1, rc.left, rc.top, rc.right, rc.bottom);
EDIT_GetLineRect(wndPtr, el, 0, ec, &rc);
SetRectRgn(hRgn2, rc.left, rc.top, rc.right, rc.bottom);
CombineRgn(oldRgn, hRgn1, hRgn2, RGN_OR);
if (el > sl + 1) {
EDIT_GetLineRect(wndPtr, sl + 1, 0, -1, &rc);
rc.bottom = rc.top + (rc.bottom - rc.top) * (el - sl - 1);
CombineRgn(hRgn1, oldRgn, 0, RGN_COPY);
SetRectRgn(hRgn2, rc.left, rc.top, rc.right, rc.bottom);
CombineRgn(oldRgn, hRgn1, hRgn2, RGN_OR);
}
}
/* Build the new selection region */
sl = EDIT_EM_LineFromChar(wndPtr, ns, 0L);
el = EDIT_EM_LineFromChar(wndPtr, ne, 0L);
sc = ns - EDIT_EM_LineIndex(wndPtr, sl, 0L);
ec = ne - EDIT_EM_LineIndex(wndPtr, el, 0L);
if (sl == el) {
EDIT_GetLineRect(wndPtr, sl, sc, ec, &rc);
SetRectRgn(newRgn, rc.left, rc.top, rc.right, rc.bottom);
} else {
EDIT_GetLineRect(wndPtr, sl, sc, -1, &rc);
SetRectRgn(hRgn1, rc.left, rc.top, rc.right, rc.bottom);
EDIT_GetLineRect(wndPtr, el, 0, ec, &rc);
SetRectRgn(hRgn2, rc.left, rc.top, rc.right, rc.bottom);
CombineRgn(newRgn, hRgn1, hRgn2, RGN_OR);
if (el > sl + 1) {
EDIT_GetLineRect(wndPtr, sl + 1, 0, -1, &rc);
rc.bottom = rc.top + (rc.bottom - rc.top) * (el - sl - 1);
CombineRgn(hRgn1, newRgn, 0, RGN_COPY);
SetRectRgn(hRgn2, rc.left, rc.top, rc.right, rc.bottom);
CombineRgn(newRgn, hRgn1, hRgn2, RGN_OR);
}
}
/* Only difference needs painting */
CombineRgn(hRgn1, oldRgn, newRgn, RGN_XOR);
/* Only part in formatting RECT needs painting */
InvalidateRgn(wndPtr->hwndSelf, hRgn1, FALSE);
DeleteObject(hRgn1);
DeleteObject(hRgn2);
DeleteObject(oldRgn);
DeleteObject(newRgn);
}
return -1L;
}
/*********************************************************************
*
* EM_SETTABSTOPS
*
*/
static LRESULT EDIT_EM_SetTabStops(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
if (!IsMultiLine(wndPtr))
return 0L;
if (es->TabStops)
free(es->TabStops);
es->NumTabStops = wParam;
if (wParam == 0)
es->TabStops = NULL;
else {
es->TabStops = (unsigned short *)xmalloc(wParam * sizeof(unsigned short));
memcpy(es->TabStops, (unsigned short *)PTR_SEG_TO_LIN(lParam),
wParam * sizeof(unsigned short));
}
return 1L;
}
/*********************************************************************
*
* EM_SETWORDBREAKPROC
*
*/
static LRESULT EDIT_EM_SetWordBreakProc(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
es->WordBreakProc = (EDITWORDBREAKPROC)lParam;
return 0L;
}
/*********************************************************************
*
* EM_UNDO
*
*/
static LRESULT EDIT_EM_Undo(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
return 0L;
}
/*********************************************************************
*
* WM_CHAR
*
*/
static LRESULT EDIT_WM_Char(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
char str[2];
char c = (char)wParam;
switch (c) {
case '\r':
case '\n':
if (IsMultiLine(wndPtr)) {
if (IsReadOnly(wndPtr)) {
EDIT_MoveHome(wndPtr, FALSE);
EDIT_MoveDownward(wndPtr, FALSE);
} else
EDIT_ReplaceSel(wndPtr, 0, (LPARAM)"\r\n");
}
break;
case '\t':
if (IsMultiLine(wndPtr) && !IsReadOnly(wndPtr))
EDIT_ReplaceSel(wndPtr, 0, (LPARAM)"\t");
break;
default:
if (!IsReadOnly(wndPtr) && (c >= ' ') && (c != 127)) {
str[0] = c;
str[1] = '\0';
EDIT_ReplaceSel(wndPtr, 0, (LPARAM)str);
}
break;
}
return 0L;
}
/*********************************************************************
*
* WM_CLEAR
*
*/
static LRESULT EDIT_WM_Clear(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
int s = LOWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int e = HIWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
char *text;
BOOL redraw;
if (s != e) {
redraw = EDIT_GetRedraw(wndPtr);
EDIT_WM_SetRedraw(wndPtr, FALSE, 0L);
ORDER_INT(s, e);
text = EDIT_GetPointer(wndPtr);
strcpy(text + s, text + e);
EDIT_BuildLineDefs(wndPtr);
EDIT_EM_SetSel(wndPtr, TRUE, MAKELPARAM(s, s));
EDIT_EM_SetModify(wndPtr, TRUE, 0L);
EDIT_NOTIFY_PARENT(wndPtr, EN_UPDATE);
EDIT_WM_SetRedraw(wndPtr, redraw, 0L);
if (redraw) {
InvalidateRect(wndPtr->hwndSelf, NULL, TRUE);
EDIT_NOTIFY_PARENT(wndPtr, EN_CHANGE);
}
}
return -1L;
}
/*********************************************************************
*
* WM_COPY
*
*/
static LRESULT EDIT_WM_Copy(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
int s = LOWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int e = HIWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
HGLOBAL hdst;
char *text;
char *dst;
char *src;
int i;
if (e == s)
return -1L;
ORDER_INT(s, e);
hdst = GlobalAlloc(GMEM_MOVEABLE, (DWORD)(e - s + 1));
dst = GlobalLock(hdst);
text = EDIT_GetPointer(wndPtr);
src = text + s;
for (i = 0 ; i < e - s ; i++)
*dst++ = *src++;
*dst = '\0';
GlobalUnlock(hdst);
OpenClipboard(wndPtr->hwndSelf);
EmptyClipboard();
SetClipboardData(CF_TEXT, hdst);
CloseClipboard();
return -1L;
}
/*********************************************************************
*
* WM_CREATE
*
*/
static LRESULT EDIT_WM_Create(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
CREATESTRUCT *cs = (CREATESTRUCT *)PTR_SEG_TO_LIN(lParam);
EDITSTATE *es;
char *windowName = NULL;
char *text;
es = xmalloc(sizeof(EDITSTATE));
memset(es, 0, sizeof(EDITSTATE));
*(EDITSTATE **)wndPtr->wExtra = es;
if (IsMultiLine(wndPtr)) {
es->BufLimit = BUFLIMIT_MULTI;
es->PasswordChar = '\0';
} else {
es->BufLimit = BUFLIMIT_SINGLE;
es->PasswordChar = (cs->style & ES_PASSWORD) ? '*' : '\0';
}
es->BufSize = IsMultiLine(wndPtr) ? BUFSTART_MULTI : BUFSTART_SINGLE;
if (cs->lpszName)
windowName = (char *)PTR_SEG_TO_LIN(cs->lpszName);
if (windowName)
es->BufSize = MAX(es->BufSize, strlen(windowName));
es->hBuf = LOCAL_Alloc(wndPtr->hInstance, LMEM_MOVEABLE, es->BufSize + 1);
text = EDIT_GetPointer(wndPtr);
if (!text) {
fprintf(stderr, "edit: WM_CREATE: unable to heap buffer, please report !\n");
return -1L;
}
if (windowName)
strcpy(text, windowName);
else
text[0] = '\0';
if (cs->style & WS_VSCROLL)
cs->style |= ES_AUTOVSCROLL;
if (cs->style & WS_HSCROLL)
cs->style |= ES_AUTOHSCROLL;
/* remove the WS_CAPTION style if it has been set - this is really a */
/* pseudo option made from a combination of WS_BORDER and WS_DLGFRAME */
if ((cs->style & WS_BORDER) && (cs->style & WS_DLGFRAME))
cs->style ^= WS_DLGFRAME;
EDIT_WM_SetFont(wndPtr, 0, 0L);
EDIT_WM_SetRedraw(wndPtr, TRUE, 0L);
return 0L;
}
/*********************************************************************
*
* WM_CUT
*
*/
static LRESULT EDIT_WM_Cut(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
EDIT_WM_Copy(wndPtr, 0, 0L);
EDIT_WM_Clear(wndPtr, 0, 0L);
return -1L;
}
/*********************************************************************
*
* WM_DESTROY
*
*/
static LRESULT EDIT_WM_Destroy(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
free(es->LineDefs);
if (es->TabStops)
free(es->TabStops);
EDIT_ReleasePointer(wndPtr);
LOCAL_Free(wndPtr->hInstance, es->hBuf);
free(es);
*(EDITSTATE **)&wndPtr->wExtra = NULL;
return 0L;
}
/*********************************************************************
*
* WM_ENABLE
*
*/
static LRESULT EDIT_WM_Enable(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
return 0L;
}
/*********************************************************************
*
* WM_ERASEBKGND
*
*/
static LRESULT EDIT_WM_EraseBkGnd(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
HBRUSH hBrush;
RECT rc;
hBrush = (HBRUSH)EDIT_SEND_CTLCOLOR(wndPtr, wParam);
GetClientRect(wndPtr->hwndSelf, &rc);
IntersectClipRect((HDC)wParam, rc.left, rc.top, rc.right, rc.bottom);
GetClipBox((HDC)wParam, &rc);
/*
* FIXME: specs say that we should UnrealizeObject() the brush,
* but the specs of UnrealizeObject() say that we shouldn't
* unrealize a stock object. The default brush that
* DefWndProc() returns is ... a stock object.
*/
FillRect((HDC)wParam, &rc, hBrush);
return -1L;
}
/*********************************************************************
*
* WM_GETDLGCODE
*
*/
static LRESULT EDIT_WM_GetDlgCode(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
return DLGC_HASSETSEL | DLGC_WANTCHARS | DLGC_WANTARROWS;
}
/*********************************************************************
*
* WM_GETFONT
*
*/
static LRESULT EDIT_WM_GetFont(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
return (LRESULT)es->hFont;
}
/*********************************************************************
*
* WM_GETTEXT
*
*/
static LRESULT EDIT_WM_GetText(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
char *text = EDIT_GetPointer(wndPtr);
int len;
LRESULT lResult = 0L;
len = strlen(text);
if ((int)wParam > len) {
strcpy((char *)PTR_SEG_TO_LIN(lParam), text);
lResult = (LRESULT)len ;
}
return lResult;
}
/*********************************************************************
*
* WM_GETTEXTLENGTH
*
*/
static LRESULT EDIT_WM_GetTextLength(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
LRESULT ret;
char *text = EDIT_GetPointer(wndPtr);
ret = (LRESULT)strlen(text);
return ret;
}
/*********************************************************************
*
* WM_HSCROLL
*
* FIXME: scrollbar code itself is broken, so this one is a hack.
*
*/
static LRESULT EDIT_WM_HScroll(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
int wndwidth = EDIT_GetWndWidth(wndPtr);
int textwidth = EDIT_GetTextWidth(wndPtr);
int charwidth = EDIT_GetAveCharWidth(wndPtr);
int xoffset = EDIT_GetXOffset(wndPtr);
int dx = 0;
BOOL not = TRUE;
LRESULT ret = 0L;
switch (wParam) {
case SB_LINELEFT:
dx = -charwidth;
break;
case SB_LINERIGHT:
dx = charwidth;
break;
case SB_PAGELEFT:
dx = -wndwidth / HSCROLL_FRACTION / charwidth * charwidth;
break;
case SB_PAGERIGHT:
dx = wndwidth / HSCROLL_FRACTION / charwidth * charwidth;
break;
case SB_LEFT:
dx = -xoffset;
break;
case SB_RIGHT:
dx = textwidth - xoffset;
break;
case SB_THUMBTRACK:
/*
* not = FALSE;
*/
case SB_THUMBPOSITION:
dx = LOWORD(lParam) * textwidth / 100 - xoffset;
break;
/* The next two are undocumented ! */
case EM_GETTHUMB:
ret = textwidth ? MAKELONG(xoffset * 100 / textwidth, 0) : 0;
break;
case EM_LINESCROLL:
dx = LOWORD(lParam);
break;
case SB_ENDSCROLL:
default:
break;
}
if (dx) {
EDIT_EM_LineScroll(wndPtr, 0, MAKELPARAM(0, dx));
if (not)
EDIT_NOTIFY_PARENT(wndPtr, EN_HSCROLL);
}
return ret;
}
/*********************************************************************
*
* WM_KEYDOWN
*
* Handling of special keys that don't produce a WM_CHAR
* (i.e. non-printable keys) & Backspace & Delete
*
*/
static LRESULT EDIT_WM_KeyDown(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
int s = LOWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int e = HIWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
BOOL shift;
BOOL control;
if (GetKeyState(VK_MENU) & 0x8000)
return 0L;
shift = GetKeyState(VK_SHIFT) & 0x8000;
control = GetKeyState(VK_CONTROL) & 0x8000;
switch (wParam) {
case VK_LEFT:
case VK_UP:
if (IsMultiLine(wndPtr) && (wParam == VK_UP))
EDIT_MoveUpward(wndPtr, shift);
else
if (control)
EDIT_MoveWordBackward(wndPtr, shift);
else
EDIT_MoveBackward(wndPtr, shift);
break;
case VK_RIGHT:
case VK_DOWN:
if (IsMultiLine(wndPtr) && (wParam == VK_DOWN))
EDIT_MoveDownward(wndPtr, shift);
else if (control)
EDIT_MoveWordForward(wndPtr, shift);
else
EDIT_MoveForward(wndPtr, shift);
break;
case VK_HOME:
EDIT_MoveHome(wndPtr, shift);
break;
case VK_END:
EDIT_MoveEnd(wndPtr, shift);
break;
case VK_PRIOR:
if (IsMultiLine(wndPtr))
EDIT_MovePageUp(wndPtr, shift);
break;
case VK_NEXT:
if (IsMultiLine(wndPtr))
EDIT_MovePageDown(wndPtr, shift);
break;
case VK_BACK:
if (!IsReadOnly(wndPtr) && !control)
if (e != s)
EDIT_WM_Clear(wndPtr, 0, 0L);
else
EDIT_DelLeft(wndPtr);
break;
case VK_DELETE:
if (!IsReadOnly(wndPtr) && !(shift && control))
if (e != s) {
if (shift)
EDIT_WM_Cut(wndPtr, 0, 0L);
else
EDIT_WM_Clear(wndPtr, 0, 0L);
} else {
if (shift)
EDIT_DelLeft(wndPtr);
else if (control)
EDIT_DelEnd(wndPtr);
else
EDIT_DelRight(wndPtr);
}
break;
case VK_INSERT:
if (shift) {
if (!IsReadOnly(wndPtr))
EDIT_WM_Paste(wndPtr, 0, 0L);
} else if (control)
EDIT_WM_Copy(wndPtr, 0, 0L);
break;
}
return 0L;
}
/*********************************************************************
*
* WM_KILLFOCUS
*
*/
static LRESULT EDIT_WM_KillFocus(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
DestroyCaret();
if(!(wndPtr->dwStyle & ES_NOHIDESEL))
EDIT_EM_SetSel(wndPtr, FALSE, MAKELPARAM(-1, 0));
EDIT_NOTIFY_PARENT(wndPtr, EN_KILLFOCUS);
return 0L;
}
/*********************************************************************
*
* WM_LBUTTONDBLCLK
*
*/
static LRESULT EDIT_WM_LButtonDblClk(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
int s;
int e = HIWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
int l = EDIT_EM_LineFromChar(wndPtr, e, 0L);
int lineindex = EDIT_EM_LineIndex(wndPtr, l, 0L);
int linelength = EDIT_EM_LineLength(wndPtr, e, 0L);
char *text = EDIT_GetPointer(wndPtr);
s = lineindex + EDIT_CallWordBreakProc(wndPtr, text + lineindex, e - lineindex, linelength, WB_LEFT);
e = lineindex + EDIT_CallWordBreakProc(wndPtr, text + lineindex, e - lineindex, linelength, WB_RIGHT);
EDIT_EM_SetSel(wndPtr, TRUE, MAKELPARAM(s, e));
return 0L;
}
/*********************************************************************
*
* WM_LBUTTONDOWN
*
*/
static LRESULT EDIT_WM_LButtonDown(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
int l;
int s;
int e;
SetFocus(wndPtr->hwndSelf);
SetCapture(wndPtr->hwndSelf);
l = EDIT_LineFromWndY(wndPtr, (INT)HIWORD(lParam));
e = EDIT_EM_LineIndex(wndPtr, l ,0L) +
EDIT_ColFromWndX(wndPtr, l, (INT)LOWORD(lParam));
if (GetKeyState(VK_SHIFT) & 0x8000)
s = LOWORD(EDIT_EM_GetSel(wndPtr, 0, 0L));
else
s = e;
EDIT_EM_SetSel(wndPtr, TRUE, MAKELPARAM(s, e));
return 0L;
}
/*********************************************************************
*
* WM_LBUTTONUP
*
*/
static LRESULT EDIT_WM_LButtonUp(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
if (GetCapture() == wndPtr->hwndSelf)
ReleaseCapture();
return 0L;
}
/*********************************************************************
*
* WM_MOUSEMOVE
*
*/
static LRESULT EDIT_WM_MouseMove(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
int Line;
int Col;
int x = (INT)LOWORD(lParam);
if (GetCapture() == wndPtr->hwndSelf) {
Line = EDIT_LineFromWndY(wndPtr, (INT)HIWORD(lParam));
Line = MAX(Line, EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0L));
Line = MIN(Line, EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0L) + EDIT_GetVisibleLineCount(wndPtr) - 1);
x = MIN(EDIT_GetWndWidth(wndPtr), MAX(0, x));
Col = EDIT_ColFromWndX(wndPtr, Line, x);
EDIT_EM_SetSel(wndPtr, FALSE, MAKELPARAM(es->SelStart,
EDIT_EM_LineIndex(wndPtr, Line, 0L) + Col));
}
return 0L;
}
/*********************************************************************
*
* WM_PAINT
*
*/
static LRESULT EDIT_WM_Paint(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
PAINTSTRUCT ps;
int i;
int firstvis = EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0L);
HDC hdc;
HFONT hFont;
HFONT oldFont = 0;
RECT rc;
RECT rcLine;
RECT rcRgn;
hdc = BeginPaint(wndPtr->hwndSelf, &ps);
GetClientRect(wndPtr->hwndSelf, &rc);
IntersectClipRect(hdc, rc.left, rc.top, rc.right, rc.bottom);
hFont = EDIT_WM_GetFont(wndPtr, 0, 0L);
if (hFont)
oldFont = SelectObject(hdc, hFont);
EDIT_SEND_CTLCOLOR(wndPtr, hdc);
GetClipBox(hdc, &rcRgn);
for (i = firstvis ; i <= MIN(firstvis + EDIT_GetVisibleLineCount(wndPtr), firstvis + es->LineCount - 1) ; i++ ) {
EDIT_GetLineRect(wndPtr, i, 0, -1, &rcLine);
if (IntersectRect(&rc, &rcRgn, &rcLine))
EDIT_PaintLine(wndPtr, hdc, i);
}
if (hFont)
SelectObject(hdc, oldFont);
EndPaint(wndPtr->hwndSelf, &ps);
return 0L;
}
/*********************************************************************
*
* WM_PASTE
*
*/
static LRESULT EDIT_WM_Paste(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
HGLOBAL hsrc;
char *src;
OpenClipboard(wndPtr->hwndSelf);
if ((hsrc = GetClipboardData(CF_TEXT))) {
src = (char *)GlobalLock(hsrc);
EDIT_ReplaceSel(wndPtr, 0, (LPARAM)src);
GlobalUnlock(hsrc);
}
CloseClipboard();
return -1L;
}
/*********************************************************************
*
* WM_SETCURSOR
*
*/
static LRESULT EDIT_WM_SetCursor(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
if (LOWORD(lParam) == HTCLIENT) {
SetCursor(LoadCursor(0, IDC_IBEAM));
return -1L;
} else
return 0L;
}
/*********************************************************************
*
* WM_SETFOCUS
*
*/
static LRESULT EDIT_WM_SetFocus(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
LPARAM sel = EDIT_EM_GetSel(wndPtr, 0, 0L);
CreateCaret(wndPtr->hwndSelf, 0, 2, EDIT_GetLineHeight(wndPtr));
EDIT_EM_SetSel(wndPtr, FALSE, sel);
ShowCaret(wndPtr->hwndSelf);
EDIT_NOTIFY_PARENT(wndPtr, EN_SETFOCUS);
return 0L;
}
/*********************************************************************
*
* WM_SETFONT
*
*/
static LRESULT EDIT_WM_SetFont(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
TEXTMETRIC tm;
EDITSTATE *es = EDITSTATEPTR(wndPtr);
LPARAM sel = EDIT_EM_GetSel(wndPtr, 0, 0L);
HDC hdc;
HFONT oldFont = 0;
es->hFont = (HFONT)wParam;
hdc = GetDC(wndPtr->hwndSelf);
if (es->hFont)
oldFont = SelectObject(hdc, es->hFont);
GetTextMetrics(hdc, &tm);
es->LineHeight = HIWORD(GetTextExtent(hdc, "", 0));
es->AveCharWidth = tm.tmAveCharWidth;
if (es->hFont)
SelectObject(hdc, oldFont);
ReleaseDC(wndPtr->hwndSelf, hdc);
EDIT_BuildLineDefs(wndPtr);
if (lParam && EDIT_GetRedraw(wndPtr))
InvalidateRect(wndPtr->hwndSelf, NULL, TRUE);
if (wndPtr->hwndSelf == GetFocus()) {
DestroyCaret();
CreateCaret(wndPtr->hwndSelf, 0, 2, EDIT_GetLineHeight(wndPtr));
EDIT_EM_SetSel(wndPtr, FALSE, sel);
ShowCaret(wndPtr->hwndSelf);
}
return 0L;
}
/*********************************************************************
*
* WM_SETREDRAW
*
*/
static LRESULT EDIT_WM_SetRedraw(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
es->Redraw = wParam ? TRUE : FALSE;
return 0L;
}
/*********************************************************************
*
* WM_SETTEXT
*
*/
static LRESULT EDIT_WM_SetText(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
EDIT_EM_SetSel(wndPtr, FALSE, MAKELPARAM(0, -1));
EDIT_WM_Clear(wndPtr, 0, 0L);
if (lParam)
EDIT_EM_ReplaceSel(wndPtr, 0, lParam);
EDIT_EM_EmptyUndoBuffer(wndPtr, 0, 0L);
EDIT_EM_SetModify(wndPtr, TRUE, 0L);
return 0L;
}
/*********************************************************************
*
* WM_SIZE
*
*/
static LRESULT EDIT_WM_Size(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
if (EDIT_GetRedraw(wndPtr) &&
((wParam == SIZE_MAXIMIZED) ||
(wParam == SIZE_RESTORED)))
InvalidateRect(wndPtr->hwndSelf, NULL, TRUE);
return 0L;
}
/*********************************************************************
*
* WM_VSCROLL
*
* FIXME: scrollbar code itself is broken, so this one is a hack.
*
*/
static LRESULT EDIT_WM_VScroll(WND *wndPtr, WPARAM wParam, LPARAM lParam)
{
int linecount = EDIT_EM_GetLineCount(wndPtr, 0, 0L);
int firstvis = EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0L);
int vislinecount = EDIT_GetVisibleLineCount(wndPtr);
int dy = 0;
BOOL not = TRUE;
LRESULT ret = 0L;
switch (wParam) {
case SB_LINEUP:
dy = -1;
break;
case SB_LINEDOWN:
dy = 1;
break;
case SB_PAGEUP:
dy = -vislinecount;
break;
case SB_PAGEDOWN:
dy = vislinecount;
break;
case SB_TOP:
dy = -firstvis;
break;
case SB_BOTTOM:
dy = linecount - 1 - firstvis;
break;
case SB_THUMBTRACK:
/*
* not = FALSE;
*/
case SB_THUMBPOSITION:
dy = LOWORD(lParam) * (linecount - 1) / 100 - firstvis;
break;
/* The next two are undocumented ! */
case EM_GETTHUMB:
ret = (linecount > 1) ? MAKELONG(firstvis * 100 / (linecount - 1), 0) : 0L;
break;
case EM_LINESCROLL:
dy = LOWORD(lParam);
break;
case SB_ENDSCROLL:
default:
break;
}
if (dy) {
EDIT_EM_LineScroll(wndPtr, 0, MAKELPARAM(dy, 0));
if (not)
EDIT_NOTIFY_PARENT(wndPtr, EN_VSCROLL);
}
return ret;
}