/*
 *	Edit control
 *
 *	Copyright  David W. Metcalfe, 1994
 *	Copyright  William Magro, 1995, 1996
 *	Copyright  Frans van Dorsselaer, 1996, 1997
 *
 */

/*
 *	please read EDIT.TODO (and update it when you change things)
 *	It also contains a discussion about the 16 to 32 bit transition.
 *
 */


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "windows.h"
#include "win.h"
#include "combo.h"
#include "local.h"
#include "resource.h"
#include "stddebug.h"
#include "debug.h"
#include "xmalloc.h"
/*
#include "callback.h"
*/

#define BUFLIMIT_MULTI		65534	/* maximum text buffer length (not including '\0') */
					/* FIXME: BTW, new specs say 65535 (do you dare ???) */
#define BUFLIMIT_SINGLE		32766
#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 */

#define EF_TEXTCHANGED		0x0001
#define EF_FOCUSED		0x0002

typedef enum
{
	END_0 = 0,
	END_DELIMIT,
	END_NONE,
	END_HARD,
	END_SOFT,
} LINE_END;

typedef struct {
	INT32 offset;
	INT32 length;
	LINE_END ending;
} LINEDEF;

typedef struct
{
	HLOCAL16 hBuf16;	/* For when a 16-bit multiline edit
				 * control gets a EM_GETHANDLE (which
				 * should return 16-bit local heap).
				 * From that point on we _have_ to keep
				 * using 16-bit local heap (apps rely
				 * on that ... bummer).
				 */
	HLOCAL32 hBuf32;	/* Don't worry about 'LOCAL'.  LOCAL32 is
				 * identical to GLOBAL32, which is
				 * essentially a HANDLE32 created with
				 * HeapAlloc(GetProcessHeap(), ...) plus
				 * a global32 (and thus local32)
				 * descriptor, which we can return upon
				 * EM_GETHANDLE32.
				 * It is 32-bit linear addressing, so
				 * everything is fine.
				 */
	LPSTR text;		/* Depending on the fact that we are a
				 * 16 or 32 bit control, this is the
				 * pointer that we get after
				 * LocalLock32(hBuf23) (which is a typecast :-)
				 * or LOCAL_Lock(hBuf16).
				 * This is always a 32-bit linear pointer.
				 */
	HFONT32 hFont;
	LINEDEF *LineDefs;	/* Internal table for (soft) linebreaks */
	INT32 TextWidth;	/* width of the widest line in pixels */
	INT32 XOffset;		/* offset of the viewport in pixels */
	INT32 FirstVisibleLine;
	INT32 LineCount;
	INT32 LineHeight;	/* height of a screen line in pixels */
	INT32 AveCharWidth;	/* average character width in pixels */
	INT32 BufLimit;
	INT32 BufSize;
	UINT32 eState;		/* EF flags */
	INT32 UndoInsertLen;
	INT32 UndoPos;
	INT32 UndoBufSize;
	HLOCAL32 hUndoBuf;
	LPSTR UndoText;
	INT32 SelStart;		/* offset of selection start, == SelEnd if no selection */
	INT32 SelEnd;		/* offset of selection end == current caret position */
	INT32 NumTabStops;
	LPINT32 TabStops;
	/*
	 *	FIXME: The following should probably be a (VOID *) that is
	 *	typecast to either 16- or 32-bit callback when used,
	 *	depending on the type of edit control (16 or 32 bit).
	 *
	 *	EDITWORDBREAKPROC WordBreakProc;
	 *
	 *	For now: no more application specific wordbreaking.
	 *	(Internal wordbreak function still works)
	 */
	CHAR PasswordChar;
	INT32 LeftMargin;
	INT32 RightMargin;
	RECT32 FormatRect;
} EDITSTATE;


#define SWAP_INT32(x,y) do { INT32 temp = (INT32)(x); (x) = (INT32)(y); (y) = temp; } while(0)
#define ORDER_INT32(x,y) do { if ((INT32)(y) < (INT32)(x)) SWAP_INT32((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 IsPassword(wndPtr) ((wndPtr)->dwStyle & ES_PASSWORD)
#define IsLower(wndPtr) ((wndPtr)->dwStyle & ES_LOWERCASE)
#define IsUpper(wndPtr) ((wndPtr)->dwStyle & ES_UPPERCASE)
#define IsNoRedraw(wndPtr) ((wndPtr)->flags & WIN_NO_REDRAW)

#define EDITSTATEPTR(wndPtr) (*(EDITSTATE **)((wndPtr)->wExtra))

#define EDIT_SEND_CTLCOLOR(wndPtr,hdc) \
    (SendMessage32A((wndPtr)->parent->hwndSelf, WM_CTLCOLOREDIT, \
		    (WPARAM32)(hdc), (LPARAM)(wndPtr)->hwndSelf ))
#define EDIT_NOTIFY_PARENT(wndPtr, wNotifyCode) \
    (SendMessage32A((wndPtr)->parent->hwndSelf, WM_COMMAND, \
		    MAKEWPARAM((wndPtr)->wIDmenu, wNotifyCode), \
		    (LPARAM)(wndPtr)->hwndSelf ))
#define DPRINTF_EDIT_MSG16(str) \
    dprintf_edit(stddeb, \
		 "edit: 16 bit : " str ": hwnd=%08x, wParam=%08x, lParam=%08x\n", \
		 (UINT32)hwnd, (UINT32)wParam, (UINT32)lParam)
#define DPRINTF_EDIT_MSG32(str) \
    dprintf_edit(stddeb, \
		 "edit: 32 bit : " str ": hwnd=%08x, wParam=%08x, lParam=%08x\n", \
		 (UINT32)hwnd, (UINT32)wParam, (UINT32)lParam)

/*********************************************************************
 *
 *	Declarations
 *
 *	Files like these should really be kept in alphabetical order.
 *
 */
LRESULT EditWndProc(HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam);

static void    EDIT_BuildLineDefs(WND *wndPtr);
static INT32   EDIT_CallWordBreakProc(WND *wndPtr, LPSTR s, INT32 index, INT32 count, INT32 action);
static INT32   EDIT_ColFromWndX(WND *wndPtr, INT32 line, INT32 x);
static void    EDIT_DelEnd(WND *wndPtr);
static void    EDIT_DelLeft(WND *wndPtr);
static void    EDIT_DelRight(WND *wndPtr);
static INT32   EDIT_GetAveCharWidth(WND *wndPtr);
static INT32   EDIT_GetLineHeight(WND *wndPtr);
static void    EDIT_GetLineRect(WND *wndPtr, INT32 line, INT32 scol, INT32 ecol, LPRECT32 rc);
static LPSTR   EDIT_GetPointer(WND *wndPtr);
static LPSTR   EDIT_GetPasswordPointer(WND *wndPtr);
static void    EDIT_GetSel(WND *wndPtr, LPINT32 s, LPINT32 e);
static INT32   EDIT_GetTextWidth(WND *wndPtr);
static LPSTR   EDIT_GetUndoPointer(WND *wndPtr);
static INT32   EDIT_GetVisibleLineCount(WND *wndPtr);
static INT32   EDIT_GetWndWidth(WND *wndPtr);
static INT32   EDIT_GetXOffset(WND *wndPtr);
static void    EDIT_InvalidateText(WND *wndPtr, INT32 start, INT32 end);
static INT32   EDIT_LineFromWndY(WND *wndPtr, INT32 y);
static BOOL32  EDIT_MakeFit(WND *wndPtr, INT32 size);
static BOOL32  EDIT_MakeUndoFit(WND *wndPtr, INT32 size);
static void    EDIT_MoveBackward(WND *wndPtr, BOOL32 extend);
static void    EDIT_MoveDownward(WND *wndPtr, BOOL32 extend);
static void    EDIT_MoveEnd(WND *wndPtr, BOOL32 extend);
static void    EDIT_MoveForward(WND *wndPtr, BOOL32 extend);
static void    EDIT_MoveHome(WND *wndPtr, BOOL32 extend);
static void    EDIT_MovePageDown(WND *wndPtr, BOOL32 extend);
static void    EDIT_MovePageUp(WND *wndPtr, BOOL32 extend);
static void    EDIT_MoveUpward(WND *wndPtr, BOOL32 extend);
static void    EDIT_MoveWordBackward(WND *wndPtr, BOOL32 extend);
static void    EDIT_MoveWordForward(WND *wndPtr, BOOL32 extend);
static void    EDIT_PaintLine(WND *wndPtr, HDC32 hdc, INT32 line, BOOL32 rev);
static INT32   EDIT_PaintText(WND *wndPtr, HDC32 hdc, INT32 x, INT32 y, INT32 line, INT32 col, INT32 count, BOOL32 rev);
static void    EDIT_ReleasePointer(WND *wndPtr);
static void    EDIT_ReleaseUndoPointer(WND *wndPtr);
static void    EDIT_SetSel(WND *wndPtr, INT32 ns, INT32 ne);
static INT32   EDIT_WndXFromCol(WND *wndPtr, INT32 line, INT32 col);
static INT32   EDIT_WndYFromLine(WND *wndPtr, INT32 line);
static INT32   EDIT_WordBreakProc(LPSTR s, INT32 index, INT32 count, INT32 action);

static LRESULT EDIT_EM_CanUndo(WND *wndPtr);
static LRESULT EDIT_EM_CharFromPos(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_EmptyUndoBuffer(WND *wndPtr);
static LRESULT EDIT_EM_FmtLines(WND *wndPtr, WPARAM32 wParam);
static LRESULT EDIT_EM_GetFirstVisibleLine(WND *wndPtr);
static LRESULT EDIT_EM_GetHandle(WND *wndPtr);
static LRESULT EDIT_EM_GetHandle16(WND *wndPtr);
static LRESULT EDIT_EM_GetLimitText(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_GetLine(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_GetLineCount(WND *wndPtr);
static LRESULT EDIT_EM_GetMargins(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_GetModify(WND *wndPtr);
static LRESULT EDIT_EM_GetPasswordChar(WND *wndPtr);
static LRESULT EDIT_EM_GetRect(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_GetRect16(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_GetSel(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_GetThumb(WND *wndPtr);
static LRESULT EDIT_EM_GetWordBreakProc(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_LineFromChar(WND *wndPtr, WPARAM32 wParam);
static LRESULT EDIT_EM_LineIndex(WND *wndPtr, WPARAM32 wParam);
static LRESULT EDIT_EM_LineLength(WND *wndPtr, WPARAM32 wParam);
static LRESULT EDIT_EM_LineScroll(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_PosFromChar(WND *wndPtr, WPARAM32 wParam);
static LRESULT EDIT_EM_ReplaceSel(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_Scroll(WND *wndPtr, WPARAM32 wParam);
static LRESULT EDIT_EM_ScrollCaret(WND *wndPtr);
static LRESULT EDIT_EM_SetHandle(WND *wndPtr, WPARAM32 wParam);
static LRESULT EDIT_EM_SetHandle16(WND *wndPtr, WPARAM32 wParam);
static LRESULT EDIT_EM_SetLimitText(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_SetMargins(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_SetModify(WND *wndPtr, WPARAM32 wParam);
static LRESULT EDIT_EM_SetPasswordChar(WND *wndPtr, WPARAM32 wParam);
static LRESULT EDIT_EM_SetReadOnly(WND *wndPtr, WPARAM32 wParam);
static LRESULT EDIT_EM_SetRect(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_SetRectNP(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_SetSel(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_SetSel16(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_SetTabStops(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_SetTabStops16(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_SetWordBreakProc(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_Undo(WND *wndPtr);

static LRESULT EDIT_WM_Char(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_WM_Clear(WND *wndPtr);
static LRESULT EDIT_WM_Command(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_WM_ContextMenu(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_WM_Copy(WND *wndPtr);
static LRESULT EDIT_WM_Cut(WND *wndPtr);
static LRESULT EDIT_WM_Create(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_WM_Destroy(WND *wndPtr);
static LRESULT EDIT_WM_Enable(WND *wndPtr, WPARAM32 wParam);
static LRESULT EDIT_WM_EraseBkGnd(WND *wndPtr, WPARAM32 wParam);
static LRESULT EDIT_WM_GetDlgCode(WND *wndPtr);
static LRESULT EDIT_WM_GetFont(WND *wndPtr);
static LRESULT EDIT_WM_GetText(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_WM_GetTextLength(WND *wndPtr);
static LRESULT EDIT_WM_HScroll(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_WM_InitMenuPopup(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_WM_KeyDown(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_WM_KillFocus(WND *wndPtr, WPARAM32 wParam);
static LRESULT EDIT_WM_LButtonDblClk(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_WM_LButtonDown(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_WM_LButtonUp(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_WM_MouseMove(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_WM_Paint(WND *wndPtr, WPARAM32 wParam);
static LRESULT EDIT_WM_Paste(WND *wndPtr);
static LRESULT EDIT_WM_SetCursor(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_WM_SetFocus(WND *wndPtr, WPARAM32 wParam);
static LRESULT EDIT_WM_SetFont(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_WM_SetRedraw(WND *wndPtr, WPARAM32 wParam);
static LRESULT EDIT_WM_SetText(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_WM_Size(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_WM_SysKeyDown(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_WM_Timer(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_WM_VScroll(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);


/*********************************************************************
 *
 *	General shortcuts for variable names:
 *
 *	INT32 l;	line
 *	INT32 c;	column
 *	INT32 s;	offset of selection start
 *	INT32 e;	offset of selection end
 *	INT32 sl;	line on which the selection starts
 *	INT32 el;	line on which the selection ends
 *	INT32 sc;	column on which the selection starts
 *	INT32 ec;	column on which the selection ends
 *	INT32 li;	line index (offset)
 *	INT32 fv;	first visible line
 *	INT32 vlc;	vissible line count
 *	INT32 lc;	line count
 *	INT32 lh;	line height (in pixels)
 *	INT32 tw;	text width (in pixels)
 *	INT32 ww;	window width (in pixels)
 *	INT32 cw;	character width (average, in pixels)
 *
 */


/*********************************************************************
 *
 *	EditWndProc()
 *
 *	The messages are in the order of the actual integer values
 *	(which can be found in include/windows.h)
 *	Whereever possible the 16 bit versions are converted to
 *	the 32 bit ones, so that we can 'fall through' to the
 *	helper functions.  These are mostly 32 bit (with a few
 *	exceptions, clearly indicated by a '16' extension to their
 *	names).
 *
 */
LRESULT EditWndProc(HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam)
{
	LRESULT lResult = 0;
	WND *wndPtr = WIN_FindWndPtr(hwnd);

	if ((!EDITSTATEPTR(wndPtr)) && (msg != WM_CREATE))
		return DefWindowProc32A(hwnd, msg, wParam, lParam);

	switch (msg) {
	case EM_GETSEL16:
		DPRINTF_EDIT_MSG16("EM_GETSEL");
		wParam = 0;
		lParam = 0;
		/* fall through */
	case EM_GETSEL32:
		DPRINTF_EDIT_MSG32("EM_GETSEL");
		lResult = EDIT_EM_GetSel(wndPtr, wParam, lParam);
		break;

	case EM_SETSEL16:
		DPRINTF_EDIT_MSG16("EM_SETSEL");
		lResult = EDIT_EM_SetSel16(wndPtr, wParam, lParam);
		break;
	case EM_SETSEL32:
		DPRINTF_EDIT_MSG32("EM_SETSEL");
		lResult = EDIT_EM_SetSel(wndPtr, wParam, lParam);
		break;

	case EM_GETRECT16:
		DPRINTF_EDIT_MSG16("EM_GETRECT");
		lResult = EDIT_EM_GetRect16(wndPtr, wParam, lParam);
		break;
	case EM_GETRECT32:
		DPRINTF_EDIT_MSG32("EM_GETRECT");
		lResult = EDIT_EM_GetRect(wndPtr, wParam, lParam);
		break;

	case EM_SETRECT16:
		DPRINTF_EDIT_MSG16("EM_SETRECT");
		/* fall through */
	case EM_SETRECT32:
		DPRINTF_EDIT_MSG32("EM_SETRECT");
		lResult = EDIT_EM_SetRect(wndPtr, wParam, lParam);
		break;

	case EM_SETRECTNP16:
		DPRINTF_EDIT_MSG16("EM_SETRECTNP");
		/* fall through */
	case EM_SETRECTNP32:
		DPRINTF_EDIT_MSG32("EM_SETRECTNP");
		lResult = EDIT_EM_SetRectNP(wndPtr, wParam, lParam);
		break;

	case EM_SCROLL16:
		DPRINTF_EDIT_MSG16("EM_SCROLL");
		/* fall through */
	case EM_SCROLL32:
		DPRINTF_EDIT_MSG32("EM_SCROLL");
		lResult = EDIT_EM_Scroll(wndPtr, wParam);
 		break;

	case EM_LINESCROLL16:
		DPRINTF_EDIT_MSG16("EM_LINESCROLL");
		wParam = (WPARAM32)(INT32)(INT16)HIWORD(lParam);
		lParam = (LPARAM)(INT32)(INT16)LOWORD(lParam);
		/* fall through */
	case EM_LINESCROLL32:
		DPRINTF_EDIT_MSG32("EM_LINESCROLL");
		lResult = EDIT_EM_LineScroll(wndPtr, wParam, lParam);
		break;

	case EM_SCROLLCARET16:
		DPRINTF_EDIT_MSG16("EM_SCROLLCARET");
		/* fall through */
	case EM_SCROLLCARET32:
		DPRINTF_EDIT_MSG32("EM_SCROLLCARET");
		lResult = EDIT_EM_ScrollCaret(wndPtr);
		break;

	case EM_GETMODIFY16:
		DPRINTF_EDIT_MSG16("EM_GETMODIFY");
		/* fall through */
	case EM_GETMODIFY32:
		DPRINTF_EDIT_MSG32("EM_GETMODIFY");
		lResult = EDIT_EM_GetModify(wndPtr);
		break;

	case EM_SETMODIFY16:
		DPRINTF_EDIT_MSG16("EM_SETMODIFY");
		/* fall through */
	case EM_SETMODIFY32:
		DPRINTF_EDIT_MSG32("EM_SETMODIFY");
		lResult = EDIT_EM_SetModify(wndPtr, wParam);
		break;

	case EM_GETLINECOUNT16:
		DPRINTF_EDIT_MSG16("EM_GETLINECOUNT");
		/* fall through */
	case EM_GETLINECOUNT32:
		DPRINTF_EDIT_MSG32("EM_GETLINECOUNT");
		lResult = EDIT_EM_GetLineCount(wndPtr);
		break;

	case EM_LINEINDEX16:
		DPRINTF_EDIT_MSG16("EM_LINEINDEX");
		/* fall through */
	case EM_LINEINDEX32:
		DPRINTF_EDIT_MSG32("EM_LINEINDEX");
		lResult = EDIT_EM_LineIndex(wndPtr, wParam);
		break;

	case EM_SETHANDLE16:
		DPRINTF_EDIT_MSG16("EM_SETHANDLE");
		lResult = EDIT_EM_SetHandle16(wndPtr, wParam);
		break;
	case EM_SETHANDLE32:
		DPRINTF_EDIT_MSG32("EM_SETHANDLE");
		lResult = EDIT_EM_SetHandle(wndPtr, wParam);
		break;

	case EM_GETHANDLE16:
		DPRINTF_EDIT_MSG16("EM_GETHANDLE");
		lResult = EDIT_EM_GetHandle16(wndPtr);
		break;
	case EM_GETHANDLE32:
		DPRINTF_EDIT_MSG32("EM_GETHANDLE");
		lResult = EDIT_EM_GetHandle(wndPtr);
		break;

	case EM_GETTHUMB16:
		DPRINTF_EDIT_MSG16("EM_GETTHUMB");
		/* fall through */
	case EM_GETTHUMB32:
		DPRINTF_EDIT_MSG32("EM_GETTHUMB");
		lResult = EDIT_EM_GetThumb(wndPtr);
		break;

	/* messages 0x00bf and 0x00c0 missing from specs */

	case WM_USER+15:
		DPRINTF_EDIT_MSG16("undocumented WM_USER+15, please report");
		/* fall through */
	case 0x00bf:
		DPRINTF_EDIT_MSG32("undocumented 0x00bf, please report");
		lResult = DefWindowProc32A(hwnd, msg, wParam, lParam);
		break;

	case WM_USER+16:
		DPRINTF_EDIT_MSG16("undocumented WM_USER+16, please report");
		/* fall through */
	case 0x00c0:
		DPRINTF_EDIT_MSG32("undocumented 0x00c0, please report");
		lResult = DefWindowProc32A(hwnd, msg, wParam, lParam);
		break;

	case EM_LINELENGTH16:
		DPRINTF_EDIT_MSG16("EM_LINELENGTH");
		/* fall through */
	case EM_LINELENGTH32:
		DPRINTF_EDIT_MSG32("EM_LINELENGTH");
		lResult = EDIT_EM_LineLength(wndPtr, wParam);
		break;

	case EM_REPLACESEL16:
		DPRINTF_EDIT_MSG16("EM_REPLACESEL");
		lParam = (LPARAM)PTR_SEG_TO_LIN((SEGPTR)lParam);
		/* fall through */
	case EM_REPLACESEL32:
		DPRINTF_EDIT_MSG32("EM_REPLACESEL");
		lResult = EDIT_EM_ReplaceSel(wndPtr, wParam, lParam);
		break;

	/* message 0x00c3 missing from specs */

	case WM_USER+19:
		DPRINTF_EDIT_MSG16("undocumented WM_USER+19, please report");
		/* fall through */
	case 0x00c3:
		DPRINTF_EDIT_MSG32("undocumented 0x00c3, please report");
		lResult = DefWindowProc32A(hwnd, msg, wParam, lParam);
		break;

	case EM_GETLINE16:
		DPRINTF_EDIT_MSG16("EM_GETLINE");
		lParam = (LPARAM)PTR_SEG_TO_LIN((SEGPTR)lParam);
		/* fall through */
	case EM_GETLINE32:
		DPRINTF_EDIT_MSG32("EM_GETLINE");
		lResult = EDIT_EM_GetLine(wndPtr, wParam, lParam);
		break;

	case EM_LIMITTEXT16:
		DPRINTF_EDIT_MSG16("EM_LIMITTEXT");
		/* fall through */
	case EM_SETLIMITTEXT32:
		DPRINTF_EDIT_MSG32("EM_SETLIMITTEXT");
		lResult = EDIT_EM_SetLimitText(wndPtr, wParam, lParam);
		break;

	case EM_CANUNDO16:
		DPRINTF_EDIT_MSG16("EM_CANUNDO");
		/* fall through */
	case EM_CANUNDO32:
		DPRINTF_EDIT_MSG32("EM_CANUNDO");
		lResult = EDIT_EM_CanUndo(wndPtr);
		break;

	case EM_UNDO16:
		DPRINTF_EDIT_MSG16("EM_UNDO");
		/* fall through */
	case EM_UNDO32:
		/* fall through */
	case WM_UNDO:
		DPRINTF_EDIT_MSG32("EM_UNDO / WM_UNDO");
		lResult = EDIT_EM_Undo(wndPtr);
		break;

	case EM_FMTLINES16:
		DPRINTF_EDIT_MSG16("EM_FMTLINES");
		/* fall through */
	case EM_FMTLINES32:
		DPRINTF_EDIT_MSG32("EM_FMTLINES");
		lResult = EDIT_EM_FmtLines(wndPtr, wParam);
		break;

	case EM_LINEFROMCHAR16:
		DPRINTF_EDIT_MSG16("EM_LINEFROMCHAR");
		/* fall through */
	case EM_LINEFROMCHAR32:
		DPRINTF_EDIT_MSG32("EM_LINEFROMCHAR");
		lResult = EDIT_EM_LineFromChar(wndPtr, wParam);
		break;

	/* message 0x00ca missing from specs */

	case WM_USER+26:
		DPRINTF_EDIT_MSG16("undocumented WM_USER+26, please report");
		/* fall through */
	case 0x00ca:
		DPRINTF_EDIT_MSG32("undocumented 0x00ca, please report");
		lResult = DefWindowProc32A(hwnd, msg, wParam, lParam);
		break;

	case EM_SETTABSTOPS16:
		DPRINTF_EDIT_MSG16("EM_SETTABSTOPS");
		lResult = EDIT_EM_SetTabStops16(wndPtr, wParam, lParam);
		break;
	case EM_SETTABSTOPS32:
		DPRINTF_EDIT_MSG32("EM_SETTABSTOPS");
		lResult = EDIT_EM_SetTabStops(wndPtr, wParam, lParam);
		break;

	case EM_SETPASSWORDCHAR16:
		DPRINTF_EDIT_MSG16("EM_SETPASSWORDCHAR");
		/* fall through */
	case EM_SETPASSWORDCHAR32:
		DPRINTF_EDIT_MSG32("EM_SETPASSWORDCHAR");
		lResult = EDIT_EM_SetPasswordChar(wndPtr, wParam);
		break;

	case EM_EMPTYUNDOBUFFER16:
		DPRINTF_EDIT_MSG16("EM_EMPTYUNDOBUFFER");
		/* fall through */
	case EM_EMPTYUNDOBUFFER32:
		DPRINTF_EDIT_MSG32("EM_EMPTYUNDOBUFFER");
		lResult = EDIT_EM_EmptyUndoBuffer(wndPtr);
		break;

	case EM_GETFIRSTVISIBLELINE16:
		DPRINTF_EDIT_MSG16("EM_GETFIRSTVISIBLELINE");
		/* fall through */
	case EM_GETFIRSTVISIBLELINE32:
		DPRINTF_EDIT_MSG32("EM_GETFIRSTVISIBLELINE");
		lResult = EDIT_EM_GetFirstVisibleLine(wndPtr);
		break;

	case EM_SETREADONLY16:
		DPRINTF_EDIT_MSG16("EM_SETREADONLY");
		/* fall through */
	case EM_SETREADONLY32:
		DPRINTF_EDIT_MSG32("EM_SETREADONLY");
		lResult = EDIT_EM_SetReadOnly(wndPtr, wParam);
 		break;

	case EM_SETWORDBREAKPROC16:
		DPRINTF_EDIT_MSG16("EM_SETWORDBREAKPROC");
		/* fall through */
	case EM_SETWORDBREAKPROC32:
		DPRINTF_EDIT_MSG32("EM_SETWORDBREAKPROC");
		lResult = EDIT_EM_SetWordBreakProc(wndPtr, wParam, lParam);
		break;

	case EM_GETWORDBREAKPROC16:
		DPRINTF_EDIT_MSG16("EM_GETWORDBREAKPROC");
		/* fall through */
	case EM_GETWORDBREAKPROC32:
		DPRINTF_EDIT_MSG32("EM_GETWORDBREAKPROC");
		lResult = EDIT_EM_GetWordBreakProc(wndPtr, wParam, lParam);
		break;

	case EM_GETPASSWORDCHAR16:
		DPRINTF_EDIT_MSG16("EM_GETPASSWORDCHAR");
		/* fall through */
	case EM_GETPASSWORDCHAR32:
		DPRINTF_EDIT_MSG32("EM_GETPASSWORDCHAR");
		lResult = EDIT_EM_GetPasswordChar(wndPtr);
		break;

	/* The following EM_xxx are new to win95 and don't exist for 16 bit */

	case EM_SETMARGINS32:
		DPRINTF_EDIT_MSG16("EM_SETMARGINS");
		lResult = EDIT_EM_SetMargins(wndPtr, wParam, lParam);
		break;

	case EM_GETMARGINS32:
		DPRINTF_EDIT_MSG16("EM_GETMARGINS");
		lResult = EDIT_EM_GetMargins(wndPtr, wParam, lParam);
		break;

	case EM_GETLIMITTEXT32:
		DPRINTF_EDIT_MSG16("EM_GETLIMITTEXT");
		lResult = EDIT_EM_GetLimitText(wndPtr, wParam, lParam);
		break;

	case EM_POSFROMCHAR32:
		DPRINTF_EDIT_MSG16("EM_POSFROMCHAR");
		lResult = EDIT_EM_PosFromChar(wndPtr, wParam);
		break;

	case EM_CHARFROMPOS32:
		DPRINTF_EDIT_MSG16("EM_CHARFROMPOS");
		lResult = EDIT_EM_CharFromPos(wndPtr, wParam, lParam);
		break;

	case WM_GETDLGCODE:
		DPRINTF_EDIT_MSG32("WM_GETDLGCODE");
		lResult = EDIT_WM_GetDlgCode(wndPtr);
		break;

	case WM_CHAR:
		DPRINTF_EDIT_MSG32("WM_CHAR");
		lResult = EDIT_WM_Char(wndPtr, wParam, lParam);
		break;

	case WM_CLEAR:
		DPRINTF_EDIT_MSG32("WM_CLEAR");
		lResult = EDIT_WM_Clear(wndPtr);
		break;

	case WM_COMMAND:
		DPRINTF_EDIT_MSG32("WM_COMMAND");
		lResult = EDIT_WM_Command(wndPtr, wParam, lParam);
		break;

 	case WM_CONTEXTMENU:
		DPRINTF_EDIT_MSG32("WM_CONTEXTMENU");
		lResult = EDIT_WM_ContextMenu(wndPtr, wParam, lParam);
		break;

	case WM_COPY:
		DPRINTF_EDIT_MSG32("WM_COPY");
		lResult = EDIT_WM_Copy(wndPtr);
		break;

	case WM_CREATE:
		DPRINTF_EDIT_MSG32("WM_CREATE");
		lResult = EDIT_WM_Create(wndPtr, wParam, lParam);
		break;

	case WM_CUT:
		DPRINTF_EDIT_MSG32("WM_CUT");
		lResult = EDIT_WM_Cut(wndPtr);
		break;

	case WM_DESTROY:
		DPRINTF_EDIT_MSG32("WM_DESTROY");
		lResult = EDIT_WM_Destroy(wndPtr);
		break;

	case WM_ENABLE:
		DPRINTF_EDIT_MSG32("WM_ENABLE");
		lResult = EDIT_WM_Enable(wndPtr, wParam);
		break;

	case WM_ERASEBKGND:
		DPRINTF_EDIT_MSG32("WM_ERASEBKGND");
		lResult = EDIT_WM_EraseBkGnd(wndPtr, wParam);
		break;

	case WM_GETFONT:
		DPRINTF_EDIT_MSG32("WM_GETFONT");
		lResult = EDIT_WM_GetFont(wndPtr);
		break;

	case WM_GETTEXT:
		DPRINTF_EDIT_MSG32("WM_GETTEXT");
		lResult = EDIT_WM_GetText(wndPtr, wParam, lParam);
		break;

	case WM_GETTEXTLENGTH:
		DPRINTF_EDIT_MSG32("WM_GETTEXTLENGTH");
		lResult = EDIT_WM_GetTextLength(wndPtr);
		break;

	case WM_HSCROLL:
		DPRINTF_EDIT_MSG32("WM_HSCROLL");
		lResult = EDIT_WM_HScroll(wndPtr, wParam, lParam);
		break;

	case WM_INITMENUPOPUP:
		DPRINTF_EDIT_MSG32("WM_INITMENUPOPUP");
		lResult = EDIT_WM_InitMenuPopup(wndPtr, wParam, lParam);
		break;

	case WM_KEYDOWN:
		DPRINTF_EDIT_MSG32("WM_KEYDOWN");
		lResult = EDIT_WM_KeyDown(wndPtr, wParam, lParam);
		break;

	case WM_KILLFOCUS:
		DPRINTF_EDIT_MSG32("WM_KILLFOCUS");
		lResult = EDIT_WM_KillFocus(wndPtr, wParam);
		break;

	case WM_LBUTTONDBLCLK:
		DPRINTF_EDIT_MSG32("WM_LBUTTONDBLCLK");
		lResult = EDIT_WM_LButtonDblClk(wndPtr, wParam, lParam);
		break;

	case WM_LBUTTONDOWN:
		DPRINTF_EDIT_MSG32("WM_LBUTTONDOWN");
		lResult = EDIT_WM_LButtonDown(wndPtr, wParam, lParam);
		break;

	case WM_LBUTTONUP:
		DPRINTF_EDIT_MSG32("WM_LBUTTONUP");
		lResult = EDIT_WM_LButtonUp(wndPtr, wParam, lParam);
		break;

	case WM_MOUSEMOVE:
		/*
		 *	DPRINTF_EDIT_MSG32("WM_MOUSEMOVE");
		 */
		lResult = EDIT_WM_MouseMove(wndPtr, wParam, lParam);
		break;

	case WM_PAINT:
		DPRINTF_EDIT_MSG32("WM_PAINT");
		lResult = EDIT_WM_Paint(wndPtr, wParam);
		break;

	case WM_PASTE:
		DPRINTF_EDIT_MSG32("WM_PASTE");
		lResult = EDIT_WM_Paste(wndPtr);
		break;

	case WM_SETCURSOR:
		/*
		 *	DPRINTF_EDIT_MSG32("WM_SETCURSOR");
		 */
		lResult = EDIT_WM_SetCursor(wndPtr, wParam, lParam);
		break;

	case WM_SETFOCUS:
		DPRINTF_EDIT_MSG32("WM_SETFOCUS");
		lResult = EDIT_WM_SetFocus(wndPtr, wParam);
		break;

	case WM_SETFONT:
		DPRINTF_EDIT_MSG32("WM_SETFONT");
		lResult = EDIT_WM_SetFont(wndPtr, wParam, lParam);
		break;

	case WM_SETREDRAW:
		DPRINTF_EDIT_MSG32("WM_SETREDRAW");
		lResult = EDIT_WM_SetRedraw(wndPtr, wParam);
		break;

	case WM_SETTEXT:
		DPRINTF_EDIT_MSG32("WM_SETTEXT");
		lResult = EDIT_WM_SetText(wndPtr, wParam, lParam);
		break;

	case WM_SIZE:
		DPRINTF_EDIT_MSG32("WM_SIZE");
		lResult = EDIT_WM_Size(wndPtr, wParam, lParam);
		break;

	case WM_SYSKEYDOWN:
		DPRINTF_EDIT_MSG32("WM_SYSKEYDOWN");
		lResult = EDIT_WM_SysKeyDown(wndPtr, wParam, lParam);
		break;

	case WM_TIMER:
		DPRINTF_EDIT_MSG32("WM_TIMER");
		lResult = EDIT_WM_Timer(wndPtr, wParam, lParam);
		break;

	case WM_VSCROLL:
		DPRINTF_EDIT_MSG32("WM_VSCROLL");
		lResult = EDIT_WM_VScroll(wndPtr, wParam, lParam);
		break;

	default:
		lResult = DefWindowProc32A(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 too 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);
	LPSTR text = EDIT_GetPasswordPointer(wndPtr);
	INT32 ww = EDIT_GetWndWidth(wndPtr);
	HDC32 hdc;
	HFONT32 hFont;
	HFONT32 oldFont = 0;
	LPSTR start, cp;
	INT32 prev, next;
	INT32 width;
	INT32 length;
	LINE_END ending;

	hdc = GetDC32(wndPtr->hwndSelf);
	hFont = (HFONT32)EDIT_WM_GetFont(wndPtr);
	if (hFont) oldFont = SelectObject32(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);
		es->LineDefs[0].ending = END_0;
		es->TextWidth = (INT32)LOWORD(GetTabbedTextExtent32A(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 = lstrlen32A(start);
			} else if ((cp > start) && (*(cp - 1) == '\r')) {
				ending = END_SOFT;
				length = cp - start - 1;
			} else {
				ending = END_HARD;
				length = cp - start;
			}
			width = (INT32)LOWORD(GetTabbedTextExtent32A(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 = (INT32)LOWORD(GetTabbedTextExtent32A(hdc, start, next,
							es->NumTabStops, es->TabStops));
				} while (width <= ww);
				if (!prev) {
					next = 0;
					do {
						prev = next;
						next++;
						width = (INT32)LOWORD(GetTabbedTextExtent32A(hdc, start, next,
								es->NumTabStops, es->TabStops));
					} while (width <= ww);
					if(!prev) prev = 1;
				}
				length = prev;
				if (EDIT_CallWordBreakProc(wndPtr, start, length - 1,
								length, WB_ISDELIMITER)) {
					length--;
					ending = END_DELIMIT;
				} else
					ending = END_NONE;
				width = (INT32)LOWORD(GetTabbedTextExtent32A(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) SelectObject32(hdc, oldFont);
	ReleaseDC32(wndPtr->hwndSelf, hdc);

	free(text);
}


/*********************************************************************
 *
 *	EDIT_CallWordBreakProc
 *
 *	Call appropriate WordBreakProc (internal or external).
 *
 *	FIXME: Heavily broken now that we have a LOCAL32 buffer.
 *	External wordbreak functions have been disabled in
 *	EM_SETWORDBREAKPROC.
 *
 */
static INT32 EDIT_CallWordBreakProc(WND *wndPtr, LPSTR s, INT32 index, INT32 count, INT32 action)
{
	return EDIT_WordBreakProc(s, index, count, action);
/*
 *	EDITWORDBREAKPROC wbp = (EDITWORDBREAKPROC)EDIT_EM_GetWordBreakProc(wndPtr, 0, 0);
 *
 *	if (!wbp) return EDIT_WordBreakProc(s, index, count, action);
 *	else {
 *		EDITSTATE *es = EDITSTATEPTR(wndPtr);
 *		SEGPTR ptr = LOCAL_LockSegptr( wndPtr->hInstance, es->hBuf16 ) +
 *			(INT16)(s - EDIT_GetPointer(wndPtr));
 *		INT ret = CallWordBreakProc( (FARPROC16)wbp, ptr,
 *						index, count, action);
 *		LOCAL_Unlock( wndPtr->hInstance, es->hBuf16 );
 *		return ret;
 *	}
 */
}


/*********************************************************************
 *
 *	EDIT_ColFromWndX
 *
 *	Calculates, for a given line and X-coordinate on the screen, the column.
 *
 */
static INT32 EDIT_ColFromWndX(WND *wndPtr, INT32 line, INT32 x)
{
	INT32 lc = (INT32)EDIT_EM_GetLineCount(wndPtr);
	INT32 li = (INT32)EDIT_EM_LineIndex(wndPtr, line);
	INT32 ll = (INT32)EDIT_EM_LineLength(wndPtr, li);
	INT32 i;

	line = MAX(0, MIN(line, lc - 1));
	for (i = 0 ; i < ll ; 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, -1, 0);
	EDIT_MoveEnd(wndPtr, TRUE);
	EDIT_WM_Clear(wndPtr);
}


/*********************************************************************
 *
 *	EDIT_DelLeft
 *
 *	Delete character to left of cursor.
 *
 */
static void EDIT_DelLeft(WND *wndPtr)
{
	EDIT_EM_SetSel(wndPtr, -1, 0);
	EDIT_MoveBackward(wndPtr, TRUE);
	EDIT_WM_Clear(wndPtr);
}


/*********************************************************************
 *
 *	EDIT_DelRight
 *
 *	Delete character to right of cursor.
 *
 */
static void EDIT_DelRight(WND *wndPtr)
{
	EDIT_EM_SetSel(wndPtr, -1, 0);
	EDIT_MoveForward(wndPtr, TRUE);
	EDIT_WM_Clear(wndPtr);
}


/*********************************************************************
 *
 *	EDIT_GetAveCharWidth
 *
 */
static INT32 EDIT_GetAveCharWidth(WND *wndPtr)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	return es->AveCharWidth;
}


/*********************************************************************
 *
 *	EDIT_GetLineHeight
 *
 */
static INT32 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, INT32 line, INT32 scol, INT32 ecol, LPRECT32 rc)
{
	rc->top = EDIT_WndYFromLine(wndPtr, line);
	rc->bottom = rc->top + EDIT_GetLineHeight(wndPtr);
	rc->left = EDIT_WndXFromCol(wndPtr, line, scol);
	rc->right = (ecol == -1) ? 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 LPSTR EDIT_GetPointer(WND *wndPtr)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	if (!es->text && (es->hBuf32 || es->hBuf16)) {
		if (es->hBuf32)
			es->text = (LPSTR)LocalLock32(es->hBuf32);
		else
			es->text = LOCAL_Lock(wndPtr->hInstance, es->hBuf16);
	}
	return es->text;
}


/*********************************************************************
 *
 *	EDIT_GetPasswordPointer
 *
 *
 */
static LPSTR EDIT_GetPasswordPointer(WND *wndPtr)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);
	LPSTR text = xstrdup(EDIT_GetPointer(wndPtr));
	LPSTR p;

	if(es->PasswordChar) {
		p = text;
		while(*p != '\0') {
			if(*p != '\r' && *p != '\n')
				*p = es->PasswordChar;
			p++;
		}
	}
	return text;
}


/*********************************************************************
 *
 *	EDIT_GetSel
 *
 *	Beware: This is not the function called on EM_GETSEL.
 *		This is the unordered version used internally
 *		(s can be > e).  No return value either.
 *
 */
static void EDIT_GetSel(WND *wndPtr, LPINT32 s, LPINT32 e)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	if (s)
		*s = es->SelStart;
	if (e)
		*e = es->SelEnd;
}


/*********************************************************************
 *
 *	EDIT_GetTextWidth
 *
 */
static INT32 EDIT_GetTextWidth(WND *wndPtr)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	return es->TextWidth;
}


/*********************************************************************
 *
 *	EDIT_GetUndoPointer
 *
 *	This acts as a LocalLock32(), but it locks only once.  This way
 *	you can call it whenever you like, without unlocking.
 *
 */
static LPSTR EDIT_GetUndoPointer(WND *wndPtr)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	if (!es->UndoText && es->hUndoBuf)
		es->UndoText = (LPSTR)LocalLock32(es->hUndoBuf);
	return es->UndoText;
}


/*********************************************************************
 *
 *	EDIT_GetVisibleLineCount
 *
 */
static INT32 EDIT_GetVisibleLineCount(WND *wndPtr)
{
	RECT32 rc;

	EDIT_EM_GetRect(wndPtr, 0, (LPARAM)&rc);
	return MAX(1, MAX(rc.bottom - rc.top, 0) / EDIT_GetLineHeight(wndPtr));
}


/*********************************************************************
 *
 *	EDIT_GetWndWidth
 *
 */
static INT32 EDIT_GetWndWidth(WND *wndPtr)
{
	RECT32 rc;

	EDIT_EM_GetRect(wndPtr, 0, (LPARAM)&rc);
	return rc.right - rc.left;
}


/*********************************************************************
 *
 *	EDIT_GetXOffset
 *
 */
static INT32 EDIT_GetXOffset(WND *wndPtr)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	return es->XOffset;
}


/*********************************************************************
 *
 *	EDIT_InvalidateText
 *
 *	Invalidate the text from offset start upto, but not including,
 *	offset end.  Useful for (re)painting the selection.
 *	Regions outside the linewidth are not invalidated.
 *	end == -1 means end == TextLength.
 *	start and end need not be ordered.
 *
 */
static void EDIT_InvalidateText(WND *wndPtr, INT32 start, INT32 end)
{
	INT32 fv = (INT32)EDIT_EM_GetFirstVisibleLine(wndPtr);
	INT32 vlc = EDIT_GetVisibleLineCount(wndPtr);
	INT32 sl;
	INT32 el;
	INT32 sc;
	INT32 ec;
	RECT32 rcWnd;
	RECT32 rcLine;
	RECT32 rcUpdate;
	INT32 l;

	if (end == start)
		return;

	if (end == -1)
		end = (INT32)EDIT_WM_GetTextLength(wndPtr);
	ORDER_INT32(start, end);
	sl = (INT32)EDIT_EM_LineFromChar(wndPtr, start);
	el = (INT32)EDIT_EM_LineFromChar(wndPtr, end);
	if ((el < fv) || (sl > fv + vlc))
		return;

	sc = start - (INT32)EDIT_EM_LineIndex(wndPtr, sl);
	ec = end - (INT32)EDIT_EM_LineIndex(wndPtr, el);
	if (sl < fv) {
		sl = fv;
		sc = 0;
	}
	if (el > fv + vlc) {
		el = fv + vlc;
		ec = (INT32)EDIT_EM_LineLength(wndPtr,
				(INT32)EDIT_EM_LineIndex(wndPtr, el));
	}
	EDIT_EM_GetRect(wndPtr, 0, (LPARAM)&rcWnd);
	if (sl == el) {
		EDIT_GetLineRect(wndPtr, sl, sc, ec, &rcLine);
		if (IntersectRect32(&rcUpdate, &rcWnd, &rcLine))
			InvalidateRect32( wndPtr->hwndSelf, &rcUpdate, FALSE );
	} else {
		EDIT_GetLineRect(wndPtr, sl, sc,
				(INT32)EDIT_EM_LineLength(wndPtr,
					(INT32)EDIT_EM_LineIndex(wndPtr, sl)),
				&rcLine);
		if (IntersectRect32(&rcUpdate, &rcWnd, &rcLine))
			InvalidateRect32( wndPtr->hwndSelf, &rcUpdate, FALSE );
		for (l = sl + 1 ; l < el ; l++) {
			EDIT_GetLineRect(wndPtr, l, 0,
				(INT32)EDIT_EM_LineLength(wndPtr,
					(INT32)EDIT_EM_LineIndex(wndPtr, l)),
				&rcLine);
			if (IntersectRect32(&rcUpdate, &rcWnd, &rcLine))
				InvalidateRect32(wndPtr->hwndSelf, &rcUpdate, FALSE);
		}
		EDIT_GetLineRect(wndPtr, el, 0, ec, &rcLine);
		if (IntersectRect32(&rcUpdate, &rcWnd, &rcLine))
			InvalidateRect32( wndPtr->hwndSelf, &rcUpdate, FALSE );
	}
}


/*********************************************************************
 *
 *	EDIT_LineFromWndY
 *
 *	Calculates, for a given Y-coordinate on the screen, the line.
 *
 */
static INT32 EDIT_LineFromWndY(WND *wndPtr, INT32 y)
{
	INT32 fv = (INT32)EDIT_EM_GetFirstVisibleLine(wndPtr);
	INT32 lh = EDIT_GetLineHeight(wndPtr);
	INT32 lc = (INT32)EDIT_EM_GetLineCount(wndPtr);

	return MAX(0, MIN(lc - 1, y / lh + fv));
}


/*********************************************************************
 *
 *	EDIT_MakeFit
 *
 *	Try to fit size + 1 bytes in the buffer.  Constrain to limits.
 *
 */
static BOOL32 EDIT_MakeFit(WND *wndPtr, INT32 size)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);
	HLOCAL32 hNew32;
	HLOCAL16 hNew16;

	if (size <= es->BufSize)
		return TRUE;
	if (size > es->BufLimit) {
		dprintf_edit(stddeb, "edit: notification EN_MAXTEXT sent\n");
		EDIT_NOTIFY_PARENT(wndPtr, EN_MAXTEXT);
		return FALSE;
	}
	size = ((size / GROWLENGTH) + 1) * GROWLENGTH;
	if (size > es->BufLimit)
		size = es->BufLimit;

	dprintf_edit(stddeb, "edit: EDIT_MakeFit: trying to ReAlloc to %d+1\n", size);

	EDIT_ReleasePointer(wndPtr);
	if (es->hBuf32) {
		if ((hNew32 = LocalReAlloc32(es->hBuf32, size + 1, 0))) {
			dprintf_edit(stddeb, "edit: EDIT_MakeFit: Old 32 bit handle %08x, new handle %08x\n", es->hBuf32, hNew32);
			es->hBuf32 = hNew32;
			es->BufSize = MIN(LocalSize32(es->hBuf32) - 1, es->BufLimit);
			if (es->BufSize < size) {
				dprintf_edit(stddeb, "edit: EDIT_MakeFit: FAILED !  We now have %d+1\n", es->BufSize);
				dprintf_edit(stddeb, "edit: notification EN_ERRSPACE sent\n");
				EDIT_NOTIFY_PARENT(wndPtr, EN_ERRSPACE);
				return FALSE;
			}
			dprintf_edit(stddeb, "edit: EDIT_MakeFit: We now have %d+1\n", es->BufSize);
			return TRUE;
		}
	} else {
		if ((hNew16 = LOCAL_ReAlloc(wndPtr->hInstance, es->hBuf16, size + 1, LMEM_MOVEABLE))) {
			dprintf_edit(stddeb, "edit: EDIT_MakeFit: Old 16 bit handle %08x, new handle %08x\n", es->hBuf16, hNew16);
			es->hBuf16 = hNew16;
			es->BufSize = MIN(LOCAL_Size(wndPtr->hInstance, es->hBuf16) - 1, es->BufLimit);
			if (es->BufSize < size) {
				dprintf_edit(stddeb, "edit: EDIT_MakeFit: FAILED !  We now have %d+1\n", es->BufSize);
				dprintf_edit(stddeb, "edit: notification EN_ERRSPACE sent\n");
				EDIT_NOTIFY_PARENT(wndPtr, EN_ERRSPACE);
				return FALSE;
			}
			dprintf_edit(stddeb, "edit: EDIT_MakeFit: We now have %d+1\n", es->BufSize);
			return TRUE;
		}
	}
	dprintf_edit(stddeb, "edit: EDIT_MakeFit: Reallocation failed\n");
	dprintf_edit(stddeb, "edit: notification EN_ERRSPACE sent\n");
	EDIT_NOTIFY_PARENT(wndPtr, EN_ERRSPACE);
	return FALSE;
}


/*********************************************************************
 *
 *	EDIT_MakeUndoFit
 *
 *	Try to fit size + 1 bytes in the undo buffer.
 *
 */
static BOOL32 EDIT_MakeUndoFit(WND *wndPtr, INT32 size)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);
	HLOCAL32 hNew;

	if (size <= es->UndoBufSize)
		return TRUE;
	size = ((size / GROWLENGTH) + 1) * GROWLENGTH;

	dprintf_edit(stddeb, "edit: EDIT_MakeUndoFit: trying to ReAlloc to %d+1\n", size);

	EDIT_ReleaseUndoPointer(wndPtr);
	if ((hNew = LocalReAlloc32(es->hUndoBuf, size + 1, 0))) {
		dprintf_edit(stddeb, "edit: EDIT_MakeUndoFit: Old handle %08x, new handle %08x\n", es->hUndoBuf, hNew);
		es->hUndoBuf = hNew;
		es->UndoBufSize = LocalSize32(es->hUndoBuf) - 1;
		if (es->UndoBufSize < size) {
			dprintf_edit(stddeb, "edit: EDIT_MakeUndoFit: FAILED !  We now have %d+1\n", es->UndoBufSize);
			return FALSE;
		}
		dprintf_edit(stddeb, "edit: EDIT_MakeUndoFit: We now have %d+1\n", es->UndoBufSize);
		return TRUE;
	}
	return FALSE;
}


/*********************************************************************
 *
 *	EDIT_MoveBackward
 *
 */
static void EDIT_MoveBackward(WND *wndPtr, BOOL32 extend)
{
	INT32 s;
	INT32 e;
	INT32 l;
	INT32 li;

	EDIT_GetSel(wndPtr, &s, &e);
	l = (INT32)EDIT_EM_LineFromChar(wndPtr, e);
	li = (INT32)EDIT_EM_LineIndex(wndPtr, l);
	if (e - li == 0) {
		if (l) {
			li = (INT32)EDIT_EM_LineIndex(wndPtr, l - 1);
			e = li + (INT32)EDIT_EM_LineLength(wndPtr, li);
		}
	} else
		e--;
	if (!extend)
		s = e;
	EDIT_SetSel(wndPtr, s, e);
	EDIT_EM_ScrollCaret(wndPtr);
}


/*********************************************************************
 *
 *	EDIT_MoveDownward
 *
 */
static void EDIT_MoveDownward(WND *wndPtr, BOOL32 extend)
{
	INT32 s;
	INT32 e;
	INT32 l;
	INT32 lc;
	INT32 li;
	INT32 x;

	EDIT_GetSel(wndPtr, &s, &e);
	l = (INT32)EDIT_EM_LineFromChar(wndPtr, e);
	lc = (INT32)EDIT_EM_GetLineCount(wndPtr);
	li = (INT32)EDIT_EM_LineIndex(wndPtr, l);
	if (l < lc - 1) {
		x = EDIT_WndXFromCol(wndPtr, l, e - li);
		l++;
		e = (INT32)EDIT_EM_LineIndex(wndPtr, l) +
				EDIT_ColFromWndX(wndPtr, l, x);
	}
	if (!extend)
		s = e;
	EDIT_SetSel(wndPtr, s, e);
	EDIT_EM_ScrollCaret(wndPtr);
}


/*********************************************************************
 *
 *	EDIT_MoveEnd
 *
 */
static void EDIT_MoveEnd(WND *wndPtr, BOOL32 extend)
{
	INT32 s;
	INT32 e;
	INT32 l;
	INT32 ll;
	INT32 li;

	EDIT_GetSel(wndPtr, &s, &e);
	l = (INT32)EDIT_EM_LineFromChar(wndPtr, e);
	ll = (INT32)EDIT_EM_LineLength(wndPtr, e);
	li = (INT32)EDIT_EM_LineIndex(wndPtr, l);
	e = li + ll;
	if (!extend)
		s = e;
	EDIT_SetSel(wndPtr, s, e);
	EDIT_EM_ScrollCaret(wndPtr);
}


/*********************************************************************
 *
 *	EDIT_MoveForward
 *
 */
static void EDIT_MoveForward(WND *wndPtr, BOOL32 extend)
{
	INT32 s;
	INT32 e;
	INT32 l;
	INT32 lc;
	INT32 ll;
	INT32 li;

	EDIT_GetSel(wndPtr, &s, &e);
	l = (INT32)EDIT_EM_LineFromChar(wndPtr, e);
	lc = (INT32)EDIT_EM_GetLineCount(wndPtr);
	ll = (INT32)EDIT_EM_LineLength(wndPtr, e);
	li = (INT32)EDIT_EM_LineIndex(wndPtr, l);
	if (e - li == ll) {
		if (l != lc - 1)
			e = (INT32)EDIT_EM_LineIndex(wndPtr, l + 1);
	} else
		e++;
	if (!extend)
		s = e;
	EDIT_SetSel(wndPtr, s, e);
	EDIT_EM_ScrollCaret(wndPtr);
}


/*********************************************************************
 *
 *	EDIT_MoveHome
 *
 *	Home key: move to beginning of line.
 *
 */
static void EDIT_MoveHome(WND *wndPtr, BOOL32 extend)
{
	INT32 s;
	INT32 e;
	INT32 l;
	INT32 li;

	EDIT_GetSel(wndPtr, &s, &e);
	l = (INT32)EDIT_EM_LineFromChar(wndPtr, e);
	li = (INT32)EDIT_EM_LineIndex(wndPtr, l);
	e = li;
	if (!extend)
		s = e;
	EDIT_SetSel(wndPtr, s, e);
	EDIT_EM_ScrollCaret(wndPtr);
}


/*********************************************************************
 *
 *	EDIT_MovePageDown
 *
 */
static void EDIT_MovePageDown(WND *wndPtr, BOOL32 extend)
{
	INT32 s;
	INT32 e;
	INT32 l;
	INT32 lc;
	INT32 li;
	INT32 x;

	EDIT_GetSel(wndPtr, &s, &e);
	l = (INT32)EDIT_EM_LineFromChar(wndPtr, e);
	lc = (INT32)EDIT_EM_GetLineCount(wndPtr);
	li = (INT32)EDIT_EM_LineIndex(wndPtr, l);
	if (l < lc - 1) {
		x = EDIT_WndXFromCol(wndPtr, l, e - li);
		l = MIN(lc - 1, l + EDIT_GetVisibleLineCount(wndPtr));
		e = (INT32)EDIT_EM_LineIndex(wndPtr, l) +
				EDIT_ColFromWndX(wndPtr, l, x);
	}
	if (!extend)
		s = e;
	EDIT_SetSel(wndPtr, s, e);
	EDIT_EM_ScrollCaret(wndPtr);
}


/*********************************************************************
 *
 *	EDIT_MovePageUp
 *
 */
static void EDIT_MovePageUp(WND *wndPtr, BOOL32 extend)
{
	INT32 s;
	INT32 e;
	INT32 l;
	INT32 li;
	INT32 x;

	EDIT_GetSel(wndPtr, &s, &e);
	l = (INT32)EDIT_EM_LineFromChar(wndPtr, e);
	li = (INT32)EDIT_EM_LineIndex(wndPtr, l);
	if (l) {
		x = EDIT_WndXFromCol(wndPtr, l, e - li);
		l = MAX(0, l - EDIT_GetVisibleLineCount(wndPtr));
		e = (INT32)EDIT_EM_LineIndex(wndPtr, l) +
				EDIT_ColFromWndX(wndPtr, l, x);
	}
	if (!extend)
		s = e;
	EDIT_SetSel(wndPtr, s, e);
	EDIT_EM_ScrollCaret(wndPtr);
}


/*********************************************************************
 *
 *	EDIT_MoveUpward
 *
 */
static void EDIT_MoveUpward(WND *wndPtr, BOOL32 extend)
{
	INT32 s;
	INT32 e;
	INT32 l;
	INT32 li;
	INT32 x;

	EDIT_GetSel(wndPtr, &s, &e);
	l = (INT32)EDIT_EM_LineFromChar(wndPtr, e);
	li = (INT32)EDIT_EM_LineIndex(wndPtr, l);
	if (l) {
		x = EDIT_WndXFromCol(wndPtr, l, e - li);
		l--;
		e = (INT32)EDIT_EM_LineIndex(wndPtr, l) +
				EDIT_ColFromWndX(wndPtr, l, x);
	}
	if (!extend)
		s = e;
	EDIT_SetSel(wndPtr, s, e);
	EDIT_EM_ScrollCaret(wndPtr);
}


/*********************************************************************
 *
 *	EDIT_MoveWordBackward
 *
 */
static void EDIT_MoveWordBackward(WND *wndPtr, BOOL32 extend)
{
	INT32 s;
	INT32 e;
	INT32 l;
	INT32 ll;
	INT32 li;
	LPSTR text;

	EDIT_GetSel(wndPtr, &s, &e);
	l = (INT32)EDIT_EM_LineFromChar(wndPtr, e);
	ll = (INT32)EDIT_EM_LineLength(wndPtr, e);
	li = (INT32)EDIT_EM_LineIndex(wndPtr, l);
	if (e - li == 0) {
		if (l) {
			li = (INT32)EDIT_EM_LineIndex(wndPtr, l - 1);
			e = li + (INT32)EDIT_EM_LineLength(wndPtr, li);
		}
	} else {
		text = EDIT_GetPointer(wndPtr);
		e = li + (INT32)EDIT_CallWordBreakProc(wndPtr,
				text + li, e - li, ll, WB_LEFT);
	}
	if (!extend)
		s = e;
	EDIT_SetSel(wndPtr, s, e);
	EDIT_EM_ScrollCaret(wndPtr);
}


/*********************************************************************
 *
 *	EDIT_MoveWordForward
 *
 */
static void EDIT_MoveWordForward(WND *wndPtr, BOOL32 extend)
{
	INT32 s;
	INT32 e;
	INT32 l;
	INT32 lc;
	INT32 ll;
	INT32 li;
	LPSTR text;

	EDIT_GetSel(wndPtr, &s, &e);
	l = (INT32)EDIT_EM_LineFromChar(wndPtr, e);
	lc = (INT32)EDIT_EM_GetLineCount(wndPtr);
	ll = (INT32)EDIT_EM_LineLength(wndPtr, e);
	li = (INT32)EDIT_EM_LineIndex(wndPtr, l);
	if (e - li == ll) {
		if (l != lc - 1)
			e = (INT32)EDIT_EM_LineIndex(wndPtr, l + 1);
	} else {
		text = EDIT_GetPointer(wndPtr);
		e = li + EDIT_CallWordBreakProc(wndPtr,
				text + li, e - li + 1, ll, WB_RIGHT);
	}
	if (!extend)
		s = e;
	EDIT_SetSel(wndPtr, s, e);
	EDIT_EM_ScrollCaret(wndPtr);
}


/*********************************************************************
 *
 *	EDIT_PaintLine
 *
 */
static void EDIT_PaintLine(WND *wndPtr, HDC32 hdc, INT32 line, BOOL32 rev)
{
	INT32 fv = (INT32)EDIT_EM_GetFirstVisibleLine(wndPtr);
	INT32 vlc = EDIT_GetVisibleLineCount(wndPtr);
	INT32 lc = (INT32)EDIT_EM_GetLineCount(wndPtr);
	INT32 li;
	INT32 ll;
	INT32 s;
	INT32 e;
	INT32 x;
	INT32 y;
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	if ((line < fv) || (line > fv + vlc) || (line >= lc))
		return;

	dprintf_edit(stddeb, "edit: EDIT_PaintLine: line=%d\n", line);

	x = EDIT_WndXFromCol(wndPtr, line, 0);
	y = EDIT_WndYFromLine(wndPtr, line);
	li = (INT32)EDIT_EM_LineIndex(wndPtr, line);
	ll = (INT32)EDIT_EM_LineLength(wndPtr, li);
	EDIT_GetSel(wndPtr, &s, &e);
	ORDER_INT32(s, e);
	s = MIN(li + ll, MAX(li, s));
	e = MIN(li + ll, MAX(li, e));
	if (rev && (s != e) &&
		((es->eState & EF_FOCUSED) || (wndPtr->dwStyle & ES_NOHIDESEL)) ) {
		x += EDIT_PaintText(wndPtr, hdc, x, y, line, 0, s - li, FALSE);
		x += EDIT_PaintText(wndPtr, hdc, x, y, line, s - li, e - s, TRUE);
		x += EDIT_PaintText(wndPtr, hdc, x, y, line, e - li, li + ll - e, FALSE);
	} else
		x += EDIT_PaintText(wndPtr, hdc, x, y, line, 0, ll, FALSE);
}


/*********************************************************************
 *
 *	EDIT_PaintText
 *
 */
static INT32 EDIT_PaintText(WND *wndPtr, HDC32 hdc, INT32 x, INT32 y, INT32 line, INT32 col, INT32 count, BOOL32 rev)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);
	COLORREF BkColor;
	COLORREF TextColor;
	INT32 ret;
	LPSTR text;
	INT32 li;
	INT32 xoff;

	if (!count)
		return 0;
	BkColor = GetBkColor32(hdc);
	TextColor = GetTextColor32(hdc);
	if (rev) {
		SetBkColor32(hdc, GetSysColor32(COLOR_HIGHLIGHT));
		SetTextColor32(hdc, GetSysColor32(COLOR_HIGHLIGHTTEXT));
	}
	text = EDIT_GetPasswordPointer(wndPtr);
	li = (INT32)EDIT_EM_LineIndex(wndPtr, line);
	xoff = EDIT_GetXOffset(wndPtr);
	ret = (INT32)LOWORD(TabbedTextOut32A(hdc, x, y, text + li + col, count,
					es->NumTabStops, es->TabStops, -xoff));
	free(text);
	if (rev) {
		SetBkColor32(hdc, BkColor);
		SetTextColor32(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->hBuf32 || es->hBuf16)) {
		if (es->hBuf32)
			LocalUnlock32(es->hBuf32);
		else
			LOCAL_Unlock(wndPtr->hInstance, es->hBuf16);
	}
	es->text = NULL;
}


/*********************************************************************
 *
 *	EDIT_ReleaseUndoPointer
 *
 *	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_ReleaseUndoPointer(WND *wndPtr)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	if (!es)
		return;
	if (es->UndoText && es->hUndoBuf)
		LocalUnlock32(es->hUndoBuf);
	es->UndoText = NULL;
}


/*********************************************************************
 *
 *	EDIT_SetSel
 *
 *	Beware: This is not the function called on EM_SETSEL.
 *		This is the unordered version used internally
 *		(s can be > e).  Doesn't accept -1 parameters either.
 *		No range checking.
 *
 */
static void EDIT_SetSel(WND *wndPtr, INT32 ns, INT32 ne)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);
	LRESULT pos;
	INT32 s;
	INT32 e;

	EDIT_EM_GetSel(wndPtr, (WPARAM32)&s, (LPARAM)&e);
	es->SelStart = ns;
	es->SelEnd = ne;
	if (!IsNoRedraw(wndPtr)) {
		if (es->eState & EF_FOCUSED) {
			pos = EDIT_EM_PosFromChar(wndPtr, ne);
			SetCaretPos16((INT16)LOWORD(pos), (INT16)HIWORD(pos));
		}
		ORDER_INT32(s, ns);
		ORDER_INT32(s, ne);
		ORDER_INT32(e, ns);
		ORDER_INT32(e, ne);
		ORDER_INT32(ns, ne);
		if (e != ns) {
			EDIT_InvalidateText(wndPtr, s, e);
			EDIT_InvalidateText(wndPtr, ns, ne);
		} else
			EDIT_InvalidateText(wndPtr, s, ne);
	}
}


/*********************************************************************
 *
 *	EDIT_WndXFromCol
 *
 *	Calculates, for a given line and column, the X-coordinate on the screen.
 *
 */
static INT32 EDIT_WndXFromCol(WND *wndPtr, INT32 line, INT32 col)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);
	LPSTR text = EDIT_GetPasswordPointer(wndPtr);
	INT32 ret;
	HDC32 hdc;
	HFONT32 hFont;
	HFONT32 oldFont = 0;
	INT32 lc = (INT32)EDIT_EM_GetLineCount(wndPtr);
	INT32 li = (INT32)EDIT_EM_LineIndex(wndPtr, line);
	INT32 ll = (INT32)EDIT_EM_LineLength(wndPtr, li);
	INT32 xoff = EDIT_GetXOffset(wndPtr);

	hdc = GetDC32(wndPtr->hwndSelf);
	hFont = (HFONT32)EDIT_WM_GetFont(wndPtr);
	if (hFont) oldFont = SelectObject32(hdc, hFont);
	line = MAX(0, MIN(line, lc - 1));
	col = MIN(col, ll);
	ret = (INT32)LOWORD(GetTabbedTextExtent32A(hdc,
			text + li, col,
			es->NumTabStops, es->TabStops)) - xoff;
	if (hFont) SelectObject32(hdc, oldFont);
	ReleaseDC32(wndPtr->hwndSelf, hdc);
	free(text);
	return ret;
}


/*********************************************************************
 *
 *	EDIT_WndYFromLine
 *
 *	Calculates, for a given line, the Y-coordinate on the screen.
 *
 */
static INT32 EDIT_WndYFromLine(WND *wndPtr, INT32 line)
{
	INT32 fv = (INT32)EDIT_EM_GetFirstVisibleLine(wndPtr);
	INT32 lh = EDIT_GetLineHeight(wndPtr);

	return (line - fv) * lh;
}


/*********************************************************************
 *
 *	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 INT32 EDIT_WordBreakProc(LPSTR s, INT32 index, INT32 count, INT32 action)
{
	INT32 ret = 0;

	dprintf_edit(stddeb, "edit: EDIT_WordBreakProc: s=%p, index=%u"
			", count=%u, 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)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	return (LRESULT)(es->UndoInsertLen || lstrlen32A(EDIT_GetUndoPointer(wndPtr)));
}


/*********************************************************************
 *
 *	EM_CHARFROMPOS
 *
 *	FIXME: do the specs mean LineIndex or LineNumber (li v.s. l) ???
 */
static LRESULT EDIT_EM_CharFromPos(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	POINT32 pt;
	RECT32 rc;
	INT32 l;
	INT32 li;
	INT32 c;

	pt.x = LOWORD(lParam);
	pt.y = HIWORD(lParam);
	GetClientRect32(wndPtr->hwndSelf, &rc);

	if (!PtInRect32(&rc, pt))
		return -1;

	l = EDIT_LineFromWndY(wndPtr, pt.y);
	li = EDIT_EM_LineIndex(wndPtr, l);
	c = EDIT_ColFromWndX(wndPtr, l, pt.x);

	return (LRESULT)MAKELONG(li + c, li);
}


/*********************************************************************
 *
 *	EM_EMPTYUNDOBUFFER
 *
 */
static LRESULT EDIT_EM_EmptyUndoBuffer(WND *wndPtr)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	es->UndoInsertLen = 0;
	*EDIT_GetUndoPointer(wndPtr) = '\0';
	return 0;
}


/*********************************************************************
 *
 *	EM_FMTLINES
 *
 */
static LRESULT EDIT_EM_FmtLines(WND *wndPtr, WPARAM32 wParam)
{
	fprintf(stdnimp, "edit: EM_FMTLINES: message not implemented\n");
	return wParam ? TRUE : FALSE;
}


/*********************************************************************
 *
 *	EM_GETFIRSTVISIBLELINE
 *
 */
static LRESULT EDIT_EM_GetFirstVisibleLine(WND *wndPtr)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	if (IsMultiLine(wndPtr))
		return (LRESULT)es->FirstVisibleLine;
	else
		return (LRESULT)EDIT_ColFromWndX(wndPtr, 0, 0);
}


/*********************************************************************
 *
 *	EM_GETHANDLE
 *
 */
static LRESULT EDIT_EM_GetHandle(WND *wndPtr)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	if (!IsMultiLine(wndPtr))
		return 0;

	if (es->hBuf32)
		return (LRESULT)es->hBuf32;
	else
		return (LRESULT)es->hBuf16;
}


/*********************************************************************
 *
 *	EM_GETHANDLE16
 *
 *	Hopefully this won't fire back at us.
 *	We always start with a buffer in 32 bit linear memory.
 *	However, with this message a 16 bit application requests
 *	a handle of 16 bit local heap memory, where it expects to find
 *	the text.
 *	It's a pitty that from this moment on we have to use this
 *	local heap, because applications may rely on the handle
 *	in the future.
 *
 *	In this function we'll try to switch to local heap.
 */
static LRESULT EDIT_EM_GetHandle16(WND *wndPtr)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);
	LPSTR text;
	HLOCAL16 newBuf;
	LPSTR newText;
	INT16 newSize;

	if (!IsMultiLine(wndPtr))
		return 0;

	if (es->hBuf16)
		return (LRESULT)es->hBuf16;

	if (!LOCAL_HeapSize(wndPtr->hInstance)) {
		if (!LocalInit(wndPtr->hInstance, 0,
			       GlobalSize16(wndPtr->hInstance))) {
			fprintf(stderr, "edit: EM_GETHANDLE: could not initialize local heap\n");
			return 0;
		}
		dprintf_edit(stddeb, "edit: EM_GETHANDLE: local heap initialized\n");
	}
	if (!(newBuf = LOCAL_Alloc(wndPtr->hInstance, LMEM_MOVEABLE,
				   EDIT_WM_GetTextLength(wndPtr) + 1))) {
		fprintf(stderr, "edit: EM_GETHANDLE: could not allocate new 16 bit buffer\n");
		return 0;
	}
	newSize = MIN(LOCAL_Size(wndPtr->hInstance, newBuf) - 1, es->BufLimit);
	if (!(newText = LOCAL_Lock(wndPtr->hInstance, newBuf))) {
		fprintf(stderr, "edit: EM_GETHANDLE: could not lock new 16 bit buffer\n");
		LOCAL_Free(wndPtr->hInstance, newBuf);
		return 0;
	}
	text = EDIT_GetPointer(wndPtr);
	lstrcpy32A(newText, text);
	EDIT_ReleasePointer(wndPtr);
	GlobalFree32(es->hBuf32);
	es->hBuf32 = (HLOCAL32)NULL;
	es->hBuf16 = newBuf;
	es->BufSize = newSize;
	es->text = newText;
	dprintf_edit(stddeb, "edit: EM_GETHANDLE: switched to 16 bit buffer\n");

	return (LRESULT)es->hBuf16;
}


/*********************************************************************
 *
 *	EM_GETLIMITTEXT
 *
 */
static LRESULT EDIT_EM_GetLimitText(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	return es->BufLimit;
}


/*********************************************************************
 *
 *	EM_GETLINE
 *
 */
static LRESULT EDIT_EM_GetLine(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	LPSTR text;
	LPSTR src;
	LPSTR dst;
	INT32 len;
	INT32 i;
	INT32 lc = (INT32)EDIT_EM_GetLineCount(wndPtr);

	if (!IsMultiLine(wndPtr))
		wParam = 0;
	if ((INT32)wParam >= lc)
		return 0;
	text = EDIT_GetPointer(wndPtr);
	src = text + (INT32)EDIT_EM_LineIndex(wndPtr, wParam);
	dst = (LPSTR)lParam;
	len = MIN(*(WORD *)dst, (INT32)EDIT_EM_LineLength(wndPtr, wParam));
	for (i = 0 ; i < len ; i++) {
		*dst = *src;
		src++;
		dst++;
	}
	return (LRESULT)len;
}


/*********************************************************************
 *
 *	EM_GETLINECOUNT
 *
 */
static LRESULT EDIT_EM_GetLineCount(WND *wndPtr)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	return (LRESULT)es->LineCount;
}


/*********************************************************************
 *
 *	EM_GETMARGINS
 *
 */
static LRESULT EDIT_EM_GetMargins(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	return (LRESULT)MAKELONG(es->LeftMargin, es->RightMargin);
}


/*********************************************************************
 *
 *	EM_GETMODIFY
 *
 */
static LRESULT EDIT_EM_GetModify(WND *wndPtr)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	return (LRESULT)((es->eState & EF_TEXTCHANGED) != 0);
}


/*********************************************************************
 *
 *	EM_GETPASSWORDCHAR
 *
 */
static LRESULT EDIT_EM_GetPasswordChar(WND *wndPtr)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	return (LRESULT)es->PasswordChar;
}


/*********************************************************************
 *
 *	EM_GETRECT
 *
 */
static LRESULT EDIT_EM_GetRect(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	CopyRect32((LPRECT32)lParam, &es->FormatRect);
	return 0;
}


/*********************************************************************
 *
 *	EM_GETRECT16
 *
 */
static LRESULT EDIT_EM_GetRect16(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	CONV_RECT32TO16(&es->FormatRect, (LPRECT16)PTR_SEG_TO_LIN((SEGPTR)lParam));
	return 0;
}


/*********************************************************************
 *
 *	EM_GETSEL
 *
 *	Returns the ordered selection range so that
 *	LOWORD(result) < HIWORD(result)
 *
 */
static LRESULT EDIT_EM_GetSel(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	INT32 s;
	INT32 e;

	EDIT_GetSel(wndPtr, &s, &e);
	ORDER_INT32(s, e);
	if (wParam)
		*(LPINT32)wParam = s;
	if (lParam)
		*(LPINT32)lParam = e;
	return MAKELONG((INT16)s, (INT16)e);
}


/*********************************************************************
 *
 *	EM_GETTHUMB
 *
 *	FIXME: is this right ?  (or should it be only HSCROLL)
 *	(and maybe only for edit controls that really have their
 *	own scrollbars) (and maybe only for multiline controls ?)
 *	All in all: very poorly documented
 *
 */
static LRESULT EDIT_EM_GetThumb(WND *wndPtr)
{
	return MAKELONG(EDIT_WM_VScroll(wndPtr, EM_GETTHUMB16, 0),
		EDIT_WM_HScroll(wndPtr, EM_GETTHUMB16, 0));
}


/*********************************************************************
 *
 *	EM_GETWORDBREAKPROC
 *
 *	FIXME: Application defined WordBreakProc should be returned
 *
 */
static LRESULT EDIT_EM_GetWordBreakProc(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
/*
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	return (LRESULT)es->WordBreakProc;
*/
	return 0;
}


/*********************************************************************
 *
 *	EM_LINEFROMCHAR
 *
 */
static LRESULT EDIT_EM_LineFromChar(WND *wndPtr, WPARAM32 wParam)
{
	INT32 l;

	if (!IsMultiLine(wndPtr))
		return 0;
	if ((INT32)wParam == -1)
		EDIT_EM_GetSel(wndPtr, (WPARAM32)&wParam, 0);	/* intentional (looks weird, doesn't it ?) */
	l = (INT32)EDIT_EM_GetLineCount(wndPtr) - 1;
	while ((INT32)EDIT_EM_LineIndex(wndPtr, l) > (INT32)wParam)
		l--;
	return (LRESULT)l;
}


/*********************************************************************
 *
 *	EM_LINEINDEX
 *
 */
static LRESULT EDIT_EM_LineIndex(WND *wndPtr, WPARAM32 wParam)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);
	INT32 e;
	INT32 l;
	INT32 lc = (INT32)EDIT_EM_GetLineCount(wndPtr);

	if ((INT32)wParam == -1) {
		EDIT_GetSel(wndPtr, NULL, &e);
		l = lc - 1;
		while (es->LineDefs[l].offset > e)
			l--;
		return (LRESULT)es->LineDefs[l].offset;
	}
	if ((INT32)wParam >= lc)
		return -1;
	return (LRESULT)es->LineDefs[(INT32)wParam].offset;
}


/*********************************************************************
 *
 *	EM_LINELENGTH
 *
 */
static LRESULT EDIT_EM_LineLength(WND *wndPtr, WPARAM32 wParam)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);
	INT32 s;
	INT32 e;
	INT32 sl;
	INT32 el;

	if (!IsMultiLine(wndPtr))
		return (LRESULT)es->LineDefs[0].length;
	if ((INT32)wParam == -1) {
		EDIT_GetSel(wndPtr, &s, &e);
		sl = (INT32)EDIT_EM_LineFromChar(wndPtr, s);
		el = (INT32)EDIT_EM_LineFromChar(wndPtr, e);
		return (LRESULT)(s - es->LineDefs[sl].offset +
				es->LineDefs[el].offset +
				es->LineDefs[el].length - e);
	}
	return (LRESULT)es->LineDefs[(INT32)EDIT_EM_LineFromChar(wndPtr, wParam)].length;
}


/*********************************************************************
 *
 *	EM_LINESCROLL
 *
 *	FIXME: is wParam in pixels or in average character widths ???
 *	FIXME: we use this internally to scroll single line controls as well
 *	(specs are vague about whether this message is valid or not for
 *	single line controls)
 *
 */
static LRESULT EDIT_EM_LineScroll(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);
	INT32 lc = (INT32)EDIT_EM_GetLineCount(wndPtr);
	INT32 fv = (INT32)EDIT_EM_GetFirstVisibleLine(wndPtr);
	INT32 nfv = MAX(0, fv + (INT32)lParam);
	INT32 xoff = EDIT_GetXOffset(wndPtr);
	INT32 nxoff = MAX(0, xoff + (INT32)wParam);
	INT32 tw = EDIT_GetTextWidth(wndPtr);
	INT32 dx;
	INT32 dy;

	if (nfv >= lc)
		nfv = lc - 1;

	if (nxoff >= tw)
		nxoff = tw;
	dx = xoff - nxoff;
	dy = EDIT_WndYFromLine(wndPtr, fv) - EDIT_WndYFromLine(wndPtr, nfv);
	if (dx || dy) {
		if (!IsNoRedraw(wndPtr))
			ScrollWindowEx32(wndPtr->hwndSelf, dx, dy, 
					 NULL, NULL, 0, NULL, (SW_INVALIDATE | SW_ERASE));
		es->FirstVisibleLine = nfv;
		es->XOffset = nxoff;
		if (IsVScrollBar(wndPtr))
			SetScrollPos32(wndPtr->hwndSelf, SB_VERT,
				EDIT_WM_VScroll(wndPtr, EM_GETTHUMB16, 0), TRUE);
		if (IsHScrollBar(wndPtr))
			SetScrollPos32(wndPtr->hwndSelf, SB_HORZ,
				EDIT_WM_HScroll(wndPtr, EM_GETTHUMB16, 0), TRUE);
	}
	if (IsMultiLine(wndPtr))
		return TRUE;
	else
		return FALSE;
}


/*********************************************************************
 *
 *	EM_POSFROMCHAR
 *
 */
static LRESULT EDIT_EM_PosFromChar(WND *wndPtr, WPARAM32 wParam)
{
	INT32 len = (INT32)EDIT_WM_GetTextLength(wndPtr);
	INT32 l;
	INT32 li;

	wParam = MIN(wParam, len);
	l = EDIT_EM_LineFromChar(wndPtr, wParam);
	li = EDIT_EM_LineIndex(wndPtr, l);
	return (LRESULT)MAKELONG(EDIT_WndXFromCol(wndPtr, l, wParam - li),
				EDIT_WndYFromLine(wndPtr, l));
}


/*********************************************************************
 *
 *	EM_REPLACESEL
 *
 */
static LRESULT EDIT_EM_ReplaceSel(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);
	LPCSTR str = (LPCSTR)lParam;
	INT32 strl = lstrlen32A(str);
	INT32 tl = (INT32)EDIT_WM_GetTextLength(wndPtr);
	INT32 utl;
	INT32 s;
	INT32 e;
	INT32 i;
	LPSTR p;
	LPSTR text;
	LPSTR utext;
	BOOL32 redraw;

	EDIT_EM_GetSel(wndPtr, (WPARAM32)&s, (LPARAM)&e);

	if ((s == e) && !strl)
		return 0;

	if (!EDIT_MakeFit(wndPtr, tl - (e - s) + strl))
		return 0;

	text = EDIT_GetPointer(wndPtr);
	utext = EDIT_GetUndoPointer(wndPtr);
	if (e != s) {
		/* there is something to be deleted */
		if ((BOOL32)wParam) {
			/* we have to be able to undo */
			utl = lstrlen32A(utext);
			if (!es->UndoInsertLen && (*utext && (s == es->UndoPos))) {
				/* undo-buffer is extended to the right */
				EDIT_MakeUndoFit(wndPtr, utl + e - s);
				lstrcpyn32A(utext + utl, text + s, e - s + 1);
			} else if (!es->UndoInsertLen && (*utext && (e == es->UndoPos))) {
				/* undo-buffer is extended to the left */
				EDIT_MakeUndoFit(wndPtr, utl + e - s);
				for (p = utext + utl ; p >= utext ; p--)
					p[e - s] = p[0];
				for (i = 0 , p = utext ; i < e - s ; i++)
					p[i] = (text + s)[i];
				es->UndoPos = s;
			} else {
				/* new undo-buffer */
				EDIT_MakeUndoFit(wndPtr, e - s);
				lstrcpyn32A(utext, text + s, e - s + 1);
				es->UndoPos = s;
			}
			/* any deletion makes the old insertion-undo invalid */
			es->UndoInsertLen = 0;
		} else
			EDIT_EM_EmptyUndoBuffer(wndPtr);

		/* now delete */
		lstrcpy32A(text + s, text + e);
	}
	if (strl) {
		/* there is an insertion */
		if ((BOOL32)wParam) {
			/* we have to be able to undo */
			if ((s == es->UndoPos) ||
					((es->UndoInsertLen) &&
					(s == es->UndoPos + es->UndoInsertLen)))
				/*
				 * insertion is new and at delete position or
				 * an extension to either left or right
				 */
				es->UndoInsertLen += strl;
			else {
				/* new insertion undo */
				es->UndoPos = s;
				es->UndoInsertLen = strl;
				/* new insertion makes old delete-buffer invalid */
				*utext = '\0';
			}
		} else
			EDIT_EM_EmptyUndoBuffer(wndPtr);

		/* now insert */
		tl = lstrlen32A(text);
		for (p = text + tl ; p >= text + s ; p--)
			p[strl] = p[0];
		for (i = 0 , p = text + s ; i < strl ; i++)
			p[i] = str[i];
		if(IsUpper(wndPtr))
			CharUpperBuff32A(p, strl);
		else if(IsLower(wndPtr))
			CharLowerBuff32A(p, strl);
		s += strl;
	}
	redraw = !IsNoRedraw(wndPtr);
	EDIT_WM_SetRedraw(wndPtr, FALSE);
	EDIT_BuildLineDefs(wndPtr);
	EDIT_EM_SetSel(wndPtr, s, s);
	EDIT_EM_ScrollCaret(wndPtr);
	EDIT_EM_SetModify(wndPtr, TRUE);
	dprintf_edit(stddeb, "edit: notification EN_UPDATE sent\n");
	EDIT_NOTIFY_PARENT(wndPtr, EN_UPDATE);
	EDIT_WM_SetRedraw(wndPtr, redraw);
	if (redraw) {
		InvalidateRect32( wndPtr->hwndSelf, NULL, TRUE );
		dprintf_edit(stddeb, "edit: notification EN_CHANGE sent\n");
		EDIT_NOTIFY_PARENT(wndPtr, EN_CHANGE);
	}
	return 0;
}


/*********************************************************************
 *
 *	EM_SCROLL
 */
static LRESULT EDIT_EM_Scroll(WND *wndPtr, WPARAM32 wParam)
{
	INT32	dy;

        switch (wParam) {
        case SB_LINEUP:
                dy = -1;
                break;
        case SB_LINEDOWN:
                dy = 1;
                break;
        case SB_PAGEUP:
	case SB_PAGEDOWN:
		dy = EDIT_GetVisibleLineCount(wndPtr);
                if( wParam == SB_PAGEUP) dy = -dy;
                break;
	default:
		return FALSE;
	}
	if (dy) {
		EDIT_EM_LineScroll(wndPtr, 0, dy);
		dprintf_edit(stddeb, "edit: notification EN_VSCROLL sent\n");
		EDIT_NOTIFY_PARENT(wndPtr, EN_VSCROLL);
	}
	return MAKELONG( ((UINT16)(INT16)dy), TRUE );
}


/*********************************************************************
 *
 *	EM_SCROLLCARET
 *
 *	Makes sure the caret is visible.
 *	FIXME: We use EM_LINESCROLL, but may we do that for single line
 *		controls ???
 *
 */
static LRESULT EDIT_EM_ScrollCaret(WND *wndPtr)
{
	INT32 e;
	INT32 l;
	INT32 li;
	INT32 fv = (INT32)EDIT_EM_GetFirstVisibleLine(wndPtr);
	INT32 vlc = EDIT_GetVisibleLineCount(wndPtr);
	INT32 ww = EDIT_GetWndWidth(wndPtr);
	INT32 cw = EDIT_GetAveCharWidth(wndPtr);
	INT32 x;
	INT32 dy = 0;
	INT32 dx = 0;

	EDIT_GetSel(wndPtr, NULL, &e);
	l = (INT32)EDIT_EM_LineFromChar(wndPtr, e);
	li = (INT32)EDIT_EM_LineIndex(wndPtr, l);
	x = EDIT_WndXFromCol(wndPtr, l, e - li);
	if (l >= fv + vlc)
		dy = l - vlc + 1 - fv;
	if (l < fv)
		dy = l - fv;
	if (x < 0)
		dx = x - ww / HSCROLL_FRACTION / cw * cw;
	if (x > ww)
		dx = x - (HSCROLL_FRACTION - 1) * ww / HSCROLL_FRACTION / cw * cw;
	if (dy || dx) {
		EDIT_EM_LineScroll(wndPtr, dx, dy);
		if (dy) {
			dprintf_edit(stddeb, "edit: notification EN_VSCROLL sent\n");
			EDIT_NOTIFY_PARENT(wndPtr, EN_VSCROLL);
		}
		if (dx) {
			dprintf_edit(stddeb, "edit: notification EN_HSCROLL sent\n");
			EDIT_NOTIFY_PARENT(wndPtr, EN_HSCROLL);
		}
	}
	return TRUE;
}


/*********************************************************************
 *
 *	EM_SETHANDLE
 *
 */
static LRESULT EDIT_EM_SetHandle(WND *wndPtr, WPARAM32 wParam)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	if (IsMultiLine(wndPtr)) {
		EDIT_ReleasePointer(wndPtr);
		/*
		 *	old buffer is freed by caller
		 */
		es->hBuf16 = (HLOCAL16)NULL;
		es->hBuf32 = (HLOCAL32)wParam;
		es->BufSize = LocalSize32(es->hBuf32) - 1;
		es->LineCount = 0;
		es->FirstVisibleLine = 0;
		es->SelStart = es->SelEnd = 0;
		EDIT_EM_EmptyUndoBuffer(wndPtr);
		EDIT_EM_SetModify(wndPtr, FALSE);
		EDIT_BuildLineDefs(wndPtr);
		if (!IsNoRedraw(wndPtr))
			InvalidateRect32( wndPtr->hwndSelf, NULL, TRUE );
		EDIT_EM_ScrollCaret(wndPtr);
	}
	return 0;
}


/*********************************************************************
 *
 *	EM_SETHANDLE16
 *
 */
static LRESULT EDIT_EM_SetHandle16(WND *wndPtr, WPARAM32 wParam)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	if (IsMultiLine(wndPtr)) {
		EDIT_ReleasePointer(wndPtr);
		/*
		 *	old buffer is freed by caller
		 */
		es->hBuf16 = (HLOCAL16)wParam;
		es->hBuf32 = (HLOCAL32)NULL;
		es->BufSize = LOCAL_Size(wndPtr->hInstance, es->hBuf16) - 1;
		es->LineCount = 0;
		es->FirstVisibleLine = 0;
		es->SelStart = es->SelEnd = 0;
		EDIT_EM_EmptyUndoBuffer(wndPtr);
		EDIT_EM_SetModify(wndPtr, FALSE);
		EDIT_BuildLineDefs(wndPtr);
		if (!IsNoRedraw(wndPtr))
			InvalidateRect32( wndPtr->hwndSelf, NULL, TRUE );
		EDIT_EM_ScrollCaret(wndPtr);
	}
	return 0;
}


/*********************************************************************
 *
 *	EM_SETLIMITTEXT
 *
 *	FIXME: in WinNT maxsize is 0x7FFFFFFF / 0xFFFFFFFF
 *	However, the windows version is not complied to yet in all of edit.c
 *
 */
static LRESULT EDIT_EM_SetLimitText(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	if (IsMultiLine(wndPtr)) {
		if (wParam)
			es->BufLimit = MIN((INT32)wParam, BUFLIMIT_MULTI);
		else
			es->BufLimit = BUFLIMIT_MULTI;
	} else {
		if (wParam)
			es->BufLimit = MIN((INT32)wParam, BUFLIMIT_SINGLE);
		else
			es->BufLimit = BUFLIMIT_SINGLE;
	}
	return 0;
}


/*********************************************************************
 *
 *	EM_SETMARGINS
 *
 *	FIXME: We let the margins be set, but we don't use them yet !?!
 *
 */
static LRESULT EDIT_EM_SetMargins(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	if (wParam & EC_USEFONTINFO) {
		if (IsMultiLine(wndPtr)) {
			/*
			 *	FIXME: do some GetABCCharWidth, or so
			 *		This is just preliminary
			 */
			es->LeftMargin = es->RightMargin = EDIT_GetAveCharWidth(wndPtr);
		} else
			es->LeftMargin = es->RightMargin = EDIT_GetAveCharWidth(wndPtr);
		return 0;
	}
	if (wParam & EC_LEFTMARGIN)
		es->LeftMargin = LOWORD(lParam);
	if (wParam & EC_RIGHTMARGIN)
		es->RightMargin = HIWORD(lParam);
	return 0;
}


/*********************************************************************
 *
 *	EM_SETMODIFY
 *
 */
static LRESULT EDIT_EM_SetModify(WND *wndPtr, WPARAM32 wParam)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	if( wParam )
	    es->eState |= EF_TEXTCHANGED;
	else
	    es->eState &= ~EF_TEXTCHANGED;
	return 0;
}


/*********************************************************************
 *
 *	EM_SETPASSWORDCHAR
 *
 *	FIXME: This imlementation is way too simple
 *
 */
static LRESULT EDIT_EM_SetPasswordChar(WND *wndPtr, WPARAM32 wParam)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	es->PasswordChar = (CHAR)wParam;
	return 0;
}


/*********************************************************************
 *
 *	EM_SETREADONLY
 *
 */
static LRESULT EDIT_EM_SetReadOnly(WND *wndPtr, WPARAM32 wParam)
{
	if ((BOOL32)wParam)
		wndPtr->dwStyle |= ES_READONLY;
	else
		wndPtr->dwStyle &= ~(DWORD)ES_READONLY;
	return TRUE;
}


/*********************************************************************
 *
 *	EM_SETRECT
 *
 */
static LRESULT EDIT_EM_SetRect(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	fprintf(stdnimp,"edit: EM_SETRECT: message not implemented\n");
	return 0;
}


/*********************************************************************
 *
 *	EM_SETRECTNP
 *
 */
static LRESULT EDIT_EM_SetRectNP(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	fprintf(stdnimp,"edit: EM_SETRECTNP: message not implemented\n");
	return 0;
}


/*********************************************************************
 *
 *	EM_SETSEL
 *
 */
static LRESULT EDIT_EM_SetSel(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	INT32 ns = (INT32)wParam;
	INT32 ne = (INT32)lParam;
	INT32 tl = (INT32)EDIT_WM_GetTextLength(wndPtr);

	if (ns == -1) {
		EDIT_GetSel(wndPtr, NULL, &ne);
		ns = ne;
	} else if ((!ns) && (ne == -1))
		ne = tl;
	else {
		ns = MAX(0, MIN(ns, tl));
		ne = MAX(0, MIN(ne, tl));
		ORDER_INT32(ns, ne);
	}
	EDIT_SetSel(wndPtr, ns, ne);
	return -1;
}


/*********************************************************************
 *
 *	EM_SETSEL16
 *
 */
static LRESULT EDIT_EM_SetSel16(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	INT32 ns = (INT32)LOWORD(lParam);
	INT32 ne = (INT32)HIWORD(lParam);

	if ((INT16)LOWORD(lParam) == -1)
		ns = -1;
	if ((!ns) && ((INT16)HIWORD(lParam) == -1))
		ne = -1;
	EDIT_EM_SetSel(wndPtr, ns, ne);
	if (!wParam)
		EDIT_EM_ScrollCaret(wndPtr);
	return -1;
}


/*********************************************************************
 *
 *	EM_SETTABSTOPS
 *
 */
static LRESULT EDIT_EM_SetTabStops(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	if (!IsMultiLine(wndPtr))
		return FALSE;
	if (es->TabStops)
		free(es->TabStops);
	es->NumTabStops = (INT32)wParam;
	if (!wParam)
		es->TabStops = NULL;
	else {
		es->TabStops = (LPINT32)xmalloc(wParam * sizeof(INT32));
		memcpy( es->TabStops, (LPINT32)lParam,
                        (INT32)wParam * sizeof(INT32) );
	}
	return TRUE;
}


/*********************************************************************
 *
 *	EM_SETTABSTOPS16
 *
 */
static LRESULT EDIT_EM_SetTabStops16(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);
	INT32 i;

	if (!IsMultiLine(wndPtr))
		return FALSE;
	if (es->TabStops)
		free(es->TabStops);
	es->NumTabStops = (INT32)wParam;
	if (!wParam)
		es->TabStops = NULL;
	else
        {
            LPINT16 p = (LPINT16)PTR_SEG_TO_LIN(lParam);
            es->TabStops = (LPINT32)xmalloc(wParam * sizeof(INT32));
            for ( i = 0 ; i < (INT32)wParam ; i++) es->TabStops[i] = *p++;
	}
	return TRUE;
}


/*********************************************************************
 *
 *	EM_SETWORDBREAKPROC
 *
 */
static LRESULT EDIT_EM_SetWordBreakProc(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
/*
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	es->WordBreakProc = (EDITWORDBREAKPROC)lParam;
*/
	return 0;
}


/*********************************************************************
 *
 *	EM_UNDO / WM_UNDO
 *
 */
static LRESULT EDIT_EM_Undo(WND *wndPtr)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);
	LPSTR utext = xstrdup(EDIT_GetUndoPointer(wndPtr));

	dprintf_edit(stddeb, "edit: before UNDO:insertion length = %d, deletion buffer = %s\n",
			es->UndoInsertLen, utext);

	EDIT_EM_SetSel(wndPtr, es->UndoPos, es->UndoPos + es->UndoInsertLen);
	EDIT_EM_EmptyUndoBuffer(wndPtr);
	EDIT_EM_ReplaceSel(wndPtr, TRUE, (LPARAM)utext);
	EDIT_EM_SetSel(wndPtr, es->UndoPos, es->UndoPos + es->UndoInsertLen);
	free(utext);

	dprintf_edit(stddeb, "edit: after UNDO: insertion length = %d, deletion buffer = %s\n",
			es->UndoInsertLen, EDIT_GetUndoPointer(wndPtr));

	return TRUE;
}


/*********************************************************************
 *
 *	WM_CHAR
 *
 */
static LRESULT EDIT_WM_Char(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	char str[2];
	unsigned char c = (unsigned char)wParam;

	switch (c) {
	case '\r':
	case '\n':
		if (IsMultiLine(wndPtr)) {
			if (IsReadOnly(wndPtr)) {
				EDIT_MoveHome(wndPtr, FALSE);
				EDIT_MoveDownward(wndPtr, FALSE);
			} else
				EDIT_EM_ReplaceSel(wndPtr, (WPARAM32)TRUE, (LPARAM)"\r\n");
		}
		break;
	case '\t':
		if (IsMultiLine(wndPtr) && !IsReadOnly(wndPtr))
			EDIT_EM_ReplaceSel(wndPtr, (WPARAM32)TRUE, (LPARAM)"\t");
		break;
	default:
		if (!IsReadOnly(wndPtr) && (c >= ' ') && (c != 127)) {
 			str[0] = c;
 			str[1] = '\0';
 			EDIT_EM_ReplaceSel(wndPtr, (WPARAM32)TRUE, (LPARAM)str);
 		}
		break;
	}
	return 0;
}


/*********************************************************************
 *
 *	WM_CLEAR
 *
 */
static LRESULT EDIT_WM_Clear(WND *wndPtr)
{
	EDIT_EM_ReplaceSel(wndPtr, TRUE, (LPARAM)"");

	return -1;
}


/*********************************************************************
 *
 *	WM_COMMAND
 *
 */
static LRESULT EDIT_WM_Command(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	if (HIWORD(wParam))
		return 0;

	switch (LOWORD(wParam)) {
		case EM_UNDO32:	
			EDIT_EM_Undo(wndPtr);
			break;
		case WM_CUT:
			EDIT_WM_Cut(wndPtr);
			break;
		case WM_COPY:
			EDIT_WM_Copy(wndPtr);
			break;
		case WM_PASTE:
			EDIT_WM_Paste(wndPtr);
			break;
		case WM_CLEAR:
			EDIT_WM_Clear(wndPtr);
			break;
		case EM_SETSEL32:
			EDIT_EM_SetSel(wndPtr, 0, -1);
			EDIT_EM_ScrollCaret(wndPtr);
			break;
		default:
			dprintf_edit(stddeb, "edit: unknown menu item, please report\n");
			break;
	}
	return -1;
}


/*********************************************************************
 *
 *	WM_CONTEXTMENU
 *
 *	Note: the resource files resource/sysres_??.rc cannot define a
 *		single popup menu.  Hence we use a (dummy) menubar
 *		containing the single popup menu as its first item.
 *
 */
static LRESULT EDIT_WM_ContextMenu(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	HMENU32 hMenu = LoadMenuIndirect32A(SYSRES_GetResPtr(SYSRES_MENU_EDITMENU));
	HMENU32 hPopup = GetSubMenu32(hMenu, 0);

	TrackPopupMenu32(hPopup, TPM_LEFTALIGN | TPM_RIGHTBUTTON, LOWORD(lParam),
			HIWORD(lParam), 0, wndPtr->hwndSelf, NULL);
	DestroyMenu32(hMenu);
	return 0;
}


/*********************************************************************
 *
 *	WM_COPY
 *
 */
static LRESULT EDIT_WM_Copy(WND *wndPtr)
{
	INT32 s;
	INT32 e;
	HGLOBAL16 hdst;
	LPSTR text;
	LPSTR dst;

	EDIT_GetSel(wndPtr, &s, &e);
	if (e == s)
		return -1;
	ORDER_INT32(s, e);
	hdst = GlobalAlloc16(GMEM_MOVEABLE, (DWORD)(e - s + 1));
	dst = GlobalLock16(hdst);
	text = EDIT_GetPointer(wndPtr);
	lstrcpyn32A(dst, text + s, e - s + 1);
	GlobalUnlock16(hdst);
	OpenClipboard32(wndPtr->hwndSelf);
	EmptyClipboard32();
	SetClipboardData16(CF_TEXT, hdst);
	CloseClipboard32();
	return -1;
}


/*********************************************************************
 *
 *	WM_CREATE
 *
 */
static LRESULT EDIT_WM_Create(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	CREATESTRUCT32A *cs = (CREATESTRUCT32A *)lParam;
	EDITSTATE *es;
	LPSTR text;

	es = xmalloc(sizeof(EDITSTATE));
	memset(es, 0, sizeof(EDITSTATE));
	*(EDITSTATE **)wndPtr->wExtra = es;

	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;

	if (IsMultiLine(wndPtr)) {
		es->BufSize = BUFSTART_MULTI;
		es->BufLimit = BUFLIMIT_MULTI;
		es->PasswordChar = '\0';
	} else {
		es->BufSize = BUFSTART_SINGLE;
		es->BufLimit = BUFLIMIT_SINGLE;
		es->PasswordChar = (cs->style & ES_PASSWORD) ? '*' : '\0';
	}
	if (!(es->hBuf32 = LocalAlloc32(LMEM_MOVEABLE, es->BufSize + 1))) {
		fprintf(stderr, "edit: WM_CREATE: unable to allocate buffer\n");
		return -1;
	}
	if (!(es->hUndoBuf = LocalAlloc32(LMEM_MOVEABLE, es->BufSize + 1))) {
		fprintf(stderr, "edit: WM_CREATE: unable to allocate undo buffer\n");
		LocalFree32(es->hBuf32);
		es->hBuf32 = (HLOCAL32)NULL;
		return -1;
	}
	es->BufSize = LocalSize32(es->hBuf32) - 1;
	es->UndoBufSize = LocalSize32(es->hUndoBuf) - 1;
	EDIT_EM_EmptyUndoBuffer(wndPtr);
	text = EDIT_GetPointer(wndPtr);
	*text = '\0';
	EDIT_BuildLineDefs(wndPtr);
	EDIT_WM_SetFont(wndPtr, 0, 0);
	if (cs->lpszName && *(cs->lpszName) != '\0')
		EDIT_EM_ReplaceSel(wndPtr, (WPARAM32)FALSE, (LPARAM)cs->lpszName);
	EDIT_WM_SetRedraw(wndPtr, TRUE);
	return 0;
}


/*********************************************************************
 *
 *	WM_CUT
 *
 */
static LRESULT EDIT_WM_Cut(WND *wndPtr)
{
	EDIT_WM_Copy(wndPtr);
	EDIT_WM_Clear(wndPtr);
	return -1;
}


/*********************************************************************
 *
 *	WM_DESTROY
 *
 */
static LRESULT EDIT_WM_Destroy(WND *wndPtr)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	free(es->LineDefs);
	if (es->TabStops)
		free(es->TabStops);
	EDIT_ReleaseUndoPointer(wndPtr);
	LocalFree32(es->hUndoBuf);
	EDIT_ReleasePointer(wndPtr);
	if (es->hBuf32)
		LocalFree32(es->hBuf32);
	else
		LOCAL_Free(wndPtr->hInstance, es->hBuf16);
	free(es);
	wndPtr->wExtra[0] = 0;

	return 0;
}


/*********************************************************************
 *
 *	WM_ENABLE
 *
 */
static LRESULT EDIT_WM_Enable(WND *wndPtr, WPARAM32 wParam)
{
	EDIT_InvalidateText(wndPtr, 0, -1);
	return 0;
}


/*********************************************************************
 *
 *	WM_ERASEBKGND
 *
 */
static LRESULT EDIT_WM_EraseBkGnd(WND *wndPtr, WPARAM32 wParam)
{
	HBRUSH32 hBrush;
	RECT32 rc;

	hBrush = (HBRUSH32)EDIT_SEND_CTLCOLOR(wndPtr, wParam);
	if (!hBrush) hBrush = (HBRUSH32)GetStockObject32(WHITE_BRUSH);

	GetClientRect32(wndPtr->hwndSelf, &rc);
	IntersectClipRect32((HDC32)wParam, rc.left, rc.top,
			     rc.right, rc.bottom);
	GetClipBox32((HDC32)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.
	 */
	FillRect32((HDC32)wParam, &rc, hBrush);
	return -1;
}


/*********************************************************************
 *
 *	WM_GETDLGCODE
 *
 */
static LRESULT EDIT_WM_GetDlgCode(WND *wndPtr)
{
	return DLGC_HASSETSEL | DLGC_WANTCHARS | DLGC_WANTARROWS;
}


/*********************************************************************
 *
 *	WM_GETFONT
 *
 */
static LRESULT EDIT_WM_GetFont(WND *wndPtr)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	return (LRESULT)es->hFont;
}


/*********************************************************************
 *
 *	WM_GETTEXT
 *
 */
static LRESULT EDIT_WM_GetText(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	LPSTR text = EDIT_GetPointer(wndPtr);
	INT32 len;
	LRESULT lResult = 0;

	len = lstrlen32A(text);
	if ((INT32)wParam > len) {
		lstrcpy32A((LPSTR)lParam, text);
		lResult = (LRESULT)len + 1;
	}
	return lResult;
}


/*********************************************************************
 *
 *	WM_GETTEXTLENGTH
 *
 */
static LRESULT EDIT_WM_GetTextLength(WND *wndPtr)
{
	LPSTR text = EDIT_GetPointer(wndPtr);

	return (LRESULT)lstrlen32A(text);
}


/*********************************************************************
 *
 *	WM_HSCROLL
 *
 *	FIXME: scrollbar code itself is broken, so this one is a hack.
 *
 */
static LRESULT EDIT_WM_HScroll(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	INT32 ww = EDIT_GetWndWidth(wndPtr);
	INT32 tw = EDIT_GetTextWidth(wndPtr);
	INT32 cw = EDIT_GetAveCharWidth(wndPtr);
	INT32 xoff = EDIT_GetXOffset(wndPtr);
	INT32 dx = 0;
	BOOL32 not = TRUE;
	LRESULT ret = 0;

	switch (wParam) {
	case SB_LINELEFT:
		dx = -cw;
		break;
	case SB_LINERIGHT:
		dx = cw;
		break;
	case SB_PAGELEFT:
		dx = -ww / HSCROLL_FRACTION / cw * cw;
		break;
	case SB_PAGERIGHT:
		dx = ww / HSCROLL_FRACTION / cw * cw;
		break;
	case SB_LEFT:
		dx = -xoff;
		break;
	case SB_RIGHT:
		dx = tw - xoff;
		break;
	case SB_THUMBTRACK:
/*
 *		not = FALSE;
 */
	case SB_THUMBPOSITION:
		dx = HIWORD(wParam) * tw / 100 - xoff;
		break;
	/* The next two are undocumented ! */
	case EM_GETTHUMB16:
		ret = tw ? xoff * 100 / tw : 0;
		break;
	case EM_LINESCROLL16:
		dx = (INT16)HIWORD(wParam);
		break;
	case SB_ENDSCROLL:
	default:
		break;
	}
	if (dx) {
		EDIT_EM_LineScroll(wndPtr, dx, 0);
		if (not) {
			dprintf_edit(stddeb, "edit: notification EN_HSCROLL sent\n");
			EDIT_NOTIFY_PARENT(wndPtr, EN_HSCROLL);
		}
	}
	return ret;
}


/*********************************************************************
 *
 *	WM_INITMENUPOPUP
 *
 *	FIXME: the message identifiers have been chosen arbitrarily,
 *		hence we use MF_BYPOSITION.
 *		We might as well use the "real" values (anybody knows ?)
 *		The menu definition is in resources/sysres_??.rc.
 *		Once these are OK, we better use MF_BYCOMMAND here
 *		(as we do in EDIT_WM_Command()).
 *
 */
static LRESULT EDIT_WM_InitMenuPopup(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	HMENU32 hPopup = (HMENU32)wParam;
	INT32 s;
	INT32 e;

	EDIT_EM_GetSel(wndPtr, (WPARAM32)&s, (LPARAM)&e);

	/* undo */
	EnableMenuItem32(hPopup, 0, MF_BYPOSITION |
		(EDIT_EM_CanUndo(wndPtr) ? MF_ENABLED : MF_GRAYED));
	/* cut */
	EnableMenuItem32(hPopup, 2, MF_BYPOSITION |
		((e - s) && !IsPassword(wndPtr) ? MF_ENABLED : MF_GRAYED));
	/* copy */
	EnableMenuItem32(hPopup, 3, MF_BYPOSITION |
		((e - s) && !IsPassword(wndPtr) ? MF_ENABLED : MF_GRAYED));
	/* paste */
	EnableMenuItem32(hPopup, 4, MF_BYPOSITION |
		(IsClipboardFormatAvailable32(CF_TEXT) ? MF_ENABLED : MF_GRAYED));
	/* delete */
	EnableMenuItem32(hPopup, 5, MF_BYPOSITION |
		((e - s) ? MF_ENABLED : MF_GRAYED));
	/* select all */
	EnableMenuItem32(hPopup, 7, MF_BYPOSITION |
		(s || (e != EDIT_WM_GetTextLength(wndPtr)) ? MF_ENABLED : MF_GRAYED));

	return 0;
}

/*********************************************************************
 *
 *      EDIT_CheckCombo
 *
 */
static BOOL32 EDIT_CheckCombo(WND *wndPtr, UINT32 msg, WPARAM32 wParam, LPARAM lParam)
{
   HWND32 hLBox;

   if( WIDGETS_IsControl32( wndPtr->parent, BIC32_COMBO ) &&
            (hLBox = COMBO_GetLBWindow( wndPtr->parent )) )
   {
       HWND32 hCombo = wndPtr->parent->hwndSelf;
       BOOL32 bUIFlip = TRUE;

       dprintf_combo(stddeb, "EDIT_CheckCombo [%04x]: handling msg %04x (%04x)\n",
				  wndPtr->hwndSelf, (UINT16)msg, (UINT16)wParam );
       switch( msg )
       {
	 case WM_KEYDOWN: /* Handle F4 and arrow keys */
	   if( wParam != VK_F4 )
	   {
	       bUIFlip = (BOOL32)SendMessage32A( hCombo, CB_GETEXTENDEDUI32, 0, 0 );
	       if( SendMessage32A( hCombo, CB_GETDROPPEDSTATE32, 0, 0 ) ) bUIFlip = FALSE;
	   }

	   if( !bUIFlip )
	       SendMessage32A( hLBox, WM_KEYDOWN, wParam, 0 );
	   else
	   {
	       /* make sure ComboLBox pops up */

	       SendMessage32A( hCombo, CB_SETEXTENDEDUI32, 0, 0 );
	       SendMessage32A( hLBox, WM_KEYDOWN, VK_F4, 0 ); 
	       SendMessage32A( hCombo, CB_SETEXTENDEDUI32, 1, 0 );
	   }
	   break;

	 case WM_SYSKEYDOWN: /* Handle Alt+up/down arrows */
	   bUIFlip = (BOOL32)SendMessage32A( hCombo, CB_GETEXTENDEDUI32, 0, 0 );

	   if( bUIFlip )
	   {
	     bUIFlip = (BOOL32)SendMessage32A( hCombo, CB_GETDROPPEDSTATE32, 0, 0 );
	     SendMessage32A( hCombo, CB_SHOWDROPDOWN32, (bUIFlip) ? FALSE : TRUE, 0 );
	   } else SendMessage32A( hLBox, WM_KEYDOWN, VK_F4, 0 );
	   break;
       }
       return TRUE;
   }
   return FALSE;
}

/*********************************************************************
 *
 *	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, WPARAM32 wParam, LPARAM lParam)
{
	INT32 s;
	INT32 e;
	BOOL32 shift;
	BOOL32 control;

	if (GetKeyState32(VK_MENU) & 0x8000)
		return 0;

	shift = GetKeyState32(VK_SHIFT) & 0x8000;
	control = GetKeyState32(VK_CONTROL) & 0x8000;

	EDIT_GetSel(wndPtr, &s, &e);
	switch (wParam) {
	case VK_F4:
	case VK_UP:
		if( EDIT_CheckCombo(wndPtr, WM_KEYDOWN, wParam, lParam) ) break;
		if( wParam == VK_F4 ) break;
                /* fall through */
	case VK_LEFT:
		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_DOWN:
		if( EDIT_CheckCombo(wndPtr, WM_KEYDOWN, wParam, lParam) ) break;
		/* fall through */
	case VK_RIGHT:
		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);
			else
				EDIT_DelLeft(wndPtr);
		break;
	case VK_DELETE:
		if (!IsReadOnly(wndPtr) && !(shift && control))
			if (e != s) {
				if (shift)
					EDIT_WM_Cut(wndPtr);
				else
					EDIT_WM_Clear(wndPtr);
			} 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);
		} else if (control)
			EDIT_WM_Copy(wndPtr);
		break;
	}
	return 0;
}


/*********************************************************************
 *
 *	WM_KILLFOCUS
 *
 */
static LRESULT EDIT_WM_KillFocus(WND *wndPtr, WPARAM32 wParam)
{
	INT32 s;
	INT32 e;
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	es->eState &= ~EF_FOCUSED;
	DestroyCaret32();
	if(!(wndPtr->dwStyle & ES_NOHIDESEL)) {
		EDIT_EM_GetSel(wndPtr, (WPARAM32)&s, (LPARAM)&e);
		EDIT_InvalidateText(wndPtr, s, e);
	}
	dprintf_edit(stddeb, "edit: notification EN_KILLFOCUS sent\n");
	EDIT_NOTIFY_PARENT(wndPtr, EN_KILLFOCUS);
	return 0;
}


/*********************************************************************
 *
 *	WM_LBUTTONDBLCLK
 *
 *	The caret position has been set on the WM_LBUTTONDOWN message
 *
 */
static LRESULT EDIT_WM_LButtonDblClk(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	INT32 s;
	INT32 e;
	INT32 l;
	INT32 li;
	INT32 ll;
	LPSTR text = EDIT_GetPointer(wndPtr);

	EDIT_GetSel(wndPtr, NULL, &e);
	l = (INT32)EDIT_EM_LineFromChar(wndPtr, e);
	li = (INT32)EDIT_EM_LineIndex(wndPtr, l);
	ll = (INT32)EDIT_EM_LineLength(wndPtr, e);
	s = li + EDIT_CallWordBreakProc (wndPtr, text + li, e - li, ll, WB_LEFT);
	e = li + EDIT_CallWordBreakProc(wndPtr, text + li, e - li, ll, WB_RIGHT);
	EDIT_EM_SetSel(wndPtr, s, e);
	EDIT_EM_ScrollCaret(wndPtr);
	return 0;
}


/*********************************************************************
 *
 *	WM_LBUTTONDOWN
 *
 */
static LRESULT EDIT_WM_LButtonDown(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	INT32 x = (INT32)(INT16)LOWORD(lParam);
	INT32 y = (INT32)(INT16)HIWORD(lParam);
	INT32 l = EDIT_LineFromWndY(wndPtr, y);
	INT32 c;
	INT32 s;
	INT32 e;
	INT32 fv = (INT32)EDIT_EM_GetFirstVisibleLine(wndPtr);
	INT32 vlc = EDIT_GetVisibleLineCount(wndPtr);
	INT32 li;

	SetFocus32(wndPtr->hwndSelf);
	SetCapture32(wndPtr->hwndSelf);
	l = MIN(fv + vlc - 1, MAX(fv, l));
	x = MIN(EDIT_GetWndWidth(wndPtr), MAX(0, x));
	c = EDIT_ColFromWndX(wndPtr, l, x);
	li = (INT32)EDIT_EM_LineIndex(wndPtr, l);
	e = li + c;
	if (GetKeyState32(VK_SHIFT) & 0x8000)
		EDIT_GetSel(wndPtr, &s, NULL);
	else
		s = e;
	EDIT_SetSel(wndPtr, s, e);
	EDIT_EM_ScrollCaret(wndPtr);
	SetTimer32(wndPtr->hwndSelf, 0, 100, NULL);
	return 0;
}


/*********************************************************************
 *
 *	WM_LBUTTONUP
 *
 */
static LRESULT EDIT_WM_LButtonUp(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	if (GetCapture32() == wndPtr->hwndSelf) {
		KillTimer32(wndPtr->hwndSelf, 0);
		ReleaseCapture();
	}
	return 0;
}


/*********************************************************************
 *
 *	WM_MOUSEMOVE
 *
 */
static LRESULT EDIT_WM_MouseMove(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	INT32 x;
	INT32 y;
	INT32 l;
	INT32 c;
	INT32 s;
	INT32 fv;
	INT32 vlc;
	INT32 li;

	if (GetCapture32() == wndPtr->hwndSelf) {
		x = (INT32)(INT16)LOWORD(lParam);
		y = (INT32)(INT16)HIWORD(lParam);
		fv = (INT32)EDIT_EM_GetFirstVisibleLine(wndPtr);
		vlc = EDIT_GetVisibleLineCount(wndPtr);
		l = EDIT_LineFromWndY(wndPtr, y);
		l = MIN(fv + vlc - 1, MAX(fv, l));
		x = MIN(EDIT_GetWndWidth(wndPtr), MAX(0, x));
		c = EDIT_ColFromWndX(wndPtr, l, x);
		EDIT_GetSel(wndPtr, &s, NULL);
		li = (INT32)EDIT_EM_LineIndex(wndPtr, l);
		EDIT_SetSel(wndPtr, s, li + c);
	}
	/*
	 *	FIXME: gotta do some scrolling if outside client (format ?)
	 *		area.  Maybe reset the timer ?
	 */
	return 0;
}


/*********************************************************************
 *
 *	WM_PAINT
 *
 */
static LRESULT EDIT_WM_Paint(WND *wndPtr, WPARAM32 wParam)
{
	PAINTSTRUCT32 ps;
	INT32 i;
	INT32 fv = (INT32)EDIT_EM_GetFirstVisibleLine(wndPtr);
	INT32 vlc = EDIT_GetVisibleLineCount(wndPtr);
	INT32 lc = (INT32)EDIT_EM_GetLineCount(wndPtr);
	HDC32 hdc;
	HFONT32 hFont;
	HFONT32 oldFont = 0;
	RECT32 rc;
	RECT32 rcLine;
	RECT32 rcRgn;
 	LRESULT pos;
 	INT32 e;
	EDITSTATE *es = EDITSTATEPTR(wndPtr);
	BOOL32 rev = IsWindowEnabled32(wndPtr->hwndSelf) &&
				((es->eState & EF_FOCUSED) ||
					(wndPtr->dwStyle & ES_NOHIDESEL));

	hdc = BeginPaint32(wndPtr->hwndSelf, &ps);
	GetClientRect32(wndPtr->hwndSelf, &rc);
	IntersectClipRect32( hdc, rc.left, rc.top, rc.right, rc.bottom );
	hFont = (HFONT32)EDIT_WM_GetFont(wndPtr);
	if (hFont)
		oldFont = (HFONT32)SelectObject32(hdc, hFont);
	EDIT_SEND_CTLCOLOR(wndPtr, hdc);
	if (!IsWindowEnabled32(wndPtr->hwndSelf))
		SetTextColor32(hdc, GetSysColor32(COLOR_GRAYTEXT));
	GetClipBox32(hdc, &rcRgn);
	for (i = fv ; i <= MIN(fv + vlc, fv + lc - 1) ; i++ ) {
		EDIT_GetLineRect(wndPtr, i, 0, -1, &rcLine);
		if (IntersectRect32(&rc, &rcRgn, &rcLine))
			EDIT_PaintLine(wndPtr, hdc, i, rev);
	}
	if (hFont) SelectObject32(hdc, oldFont);
	if (es->eState & EF_FOCUSED) {
		EDIT_GetSel(wndPtr, NULL, &e);
		pos = EDIT_EM_PosFromChar(wndPtr, e);
		SetCaretPos16((INT16)LOWORD(pos), (INT16)HIWORD(pos));
	}
	EndPaint32(wndPtr->hwndSelf, &ps);
	return 0;
}


/*********************************************************************
 *
 *	WM_PASTE
 *
 */
static LRESULT EDIT_WM_Paste(WND *wndPtr)
{
	HGLOBAL16 hsrc;
	LPSTR src;

	OpenClipboard32(wndPtr->hwndSelf);
	if ((hsrc = GetClipboardData16(CF_TEXT))) {
		src = (LPSTR)GlobalLock16(hsrc);
		EDIT_EM_ReplaceSel(wndPtr, (WPARAM32)TRUE, (LPARAM)src);
		GlobalUnlock16(hsrc);
	}
	CloseClipboard32();
	return -1;
}


/*********************************************************************
 *
 *	WM_SETCURSOR
 *
 */
static LRESULT EDIT_WM_SetCursor(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	if (LOWORD(lParam) == HTCLIENT) {
		SetCursor16(LoadCursor16(0, IDC_IBEAM));
		return -1;
	} else
		return 0;
}


/*********************************************************************
 *
 *	WM_SETFOCUS
 *
 */
static LRESULT EDIT_WM_SetFocus(WND *wndPtr, WPARAM32 wParam)
{
	INT32 s;
	INT32 e;
	EDITSTATE *es = EDITSTATEPTR(wndPtr);

	es->eState |= EF_FOCUSED;
	EDIT_GetSel(wndPtr, &s, &e);
	CreateCaret32(wndPtr->hwndSelf, 0, 2, EDIT_GetLineHeight(wndPtr));
	EDIT_SetSel(wndPtr, s, e);
	if(!(wndPtr->dwStyle & ES_NOHIDESEL))
		EDIT_InvalidateText(wndPtr, s, e);
	ShowCaret32(wndPtr->hwndSelf);
	dprintf_edit(stddeb, "edit: notification EN_SETFOCUS sent\n");
	EDIT_NOTIFY_PARENT(wndPtr, EN_SETFOCUS);
	return 0;
}


/*********************************************************************
 *
 *	WM_SETFONT
 *
 */
static LRESULT EDIT_WM_SetFont(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	TEXTMETRIC32A tm;
	EDITSTATE *es = EDITSTATEPTR(wndPtr);
	INT32 s;
	INT32 e;
	HDC32 hdc;
	HFONT32 oldFont = 0;

	EDIT_GetSel(wndPtr, &s, &e);
	es->hFont = (HFONT32)wParam;
	hdc = GetDC32(wndPtr->hwndSelf);
	if (es->hFont) oldFont = SelectObject32(hdc, es->hFont);
	GetTextMetrics32A(hdc, &tm);
	es->LineHeight = tm.tmHeight;
	es->AveCharWidth = tm.tmAveCharWidth;
	if (es->hFont) SelectObject32(hdc, oldFont);
	ReleaseDC32(wndPtr->hwndSelf, hdc);
	EDIT_BuildLineDefs(wndPtr);
	if ((BOOL32)lParam && !IsNoRedraw(wndPtr))
		InvalidateRect32( wndPtr->hwndSelf, NULL, TRUE );
	if (es->eState & EF_FOCUSED) {
		DestroyCaret32();
		CreateCaret32(wndPtr->hwndSelf, 0, 2, EDIT_GetLineHeight(wndPtr));
		EDIT_SetSel(wndPtr, s, e);
		ShowCaret32(wndPtr->hwndSelf);
	}
	return 0;
}


/*********************************************************************
 *
 *	WM_SETREDRAW
 *
 */
static LRESULT EDIT_WM_SetRedraw(WND *wndPtr, WPARAM32 wParam)
{
	if( wParam )
	    wndPtr->flags &= ~WIN_NO_REDRAW;
	else
	    wndPtr->flags |= WIN_NO_REDRAW;
	return 0;
}


/*********************************************************************
 *
 *	WM_SETTEXT
 *
 */
static LRESULT EDIT_WM_SetText(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	EDIT_EM_SetSel(wndPtr, 0, -1);
	if (lParam)
	{
		dprintf_edit(stddeb,"\t'%s'\n", (char*)lParam );
		EDIT_EM_ReplaceSel(wndPtr, (WPARAM32)FALSE, lParam);
	}
	EDIT_EM_SetModify(wndPtr, TRUE);
	EDIT_EM_ScrollCaret(wndPtr);
	return 1;
}


/*********************************************************************
 *
 *	WM_SIZE
 *
 *	FIXME: What about that FormatRect ???
 *
 */
static LRESULT EDIT_WM_Size(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	EDITSTATE *es = EDITSTATEPTR(wndPtr);
	INT32 e;
	
	EDIT_GetSel(wndPtr, 0, &e);
	GetClientRect32(wndPtr->hwndSelf, &es->FormatRect);
	if (!IsNoRedraw(wndPtr) &&
			((wParam == SIZE_MAXIMIZED) ||
				(wParam == SIZE_RESTORED))) {
		if (IsMultiLine(wndPtr) && IsWordWrap(wndPtr))
			EDIT_BuildLineDefs(wndPtr);
		InvalidateRect32( wndPtr->hwndSelf, NULL, TRUE );
	}
	return 0;
}


/*********************************************************************
 *
 *	WM_SYSKEYDOWN
 *
 */
static LRESULT EDIT_WM_SysKeyDown(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	if ((wParam == VK_BACK) && (lParam & 0x2000) &&
			(BOOL32)EDIT_EM_CanUndo(wndPtr))
		EDIT_EM_Undo(wndPtr);
	else if( wParam == VK_UP || wParam == VK_DOWN )
		EDIT_CheckCombo( wndPtr, WM_SYSKEYDOWN, wParam, lParam );
	return 0;
}


/*********************************************************************
 *
 *	WM_TIMER
 *
 */
static LRESULT EDIT_WM_Timer(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
/*
 *	FIXME: gotta do some scrolling here, like
 *		EDIT_EM_LineScroll(wndPtr, 0, 1);
 */
	return 0;
}


/*********************************************************************
 *
 *	WM_VSCROLL
 *
 *	FIXME: scrollbar code itself is broken, so this one is a hack.
 *
 */
static LRESULT EDIT_WM_VScroll(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
	INT32 lc, fv;
	INT32 dy = 0;
	BOOL32 not = TRUE;
	LRESULT ret = 0;

	switch (wParam) {
	case SB_LINEUP:
	case SB_LINEDOWN:
	case SB_PAGEUP:
	case SB_PAGEDOWN:
		EDIT_EM_Scroll( wndPtr, wParam );
		return ret;
	default:
		lc = (INT32)EDIT_EM_GetLineCount(wndPtr);
		fv = (INT32)EDIT_EM_GetFirstVisibleLine(wndPtr);
		switch( wParam ) {
		case SB_TOP:
			dy = -fv;
			break;
		case SB_BOTTOM:
			dy = lc - 1 - fv;
			break;
		case SB_THUMBTRACK:
			not = FALSE;
			/* fall through */
		case SB_THUMBPOSITION:
			dy = HIWORD(wParam) * (lc - 1) / 100 - fv;
			break;
		/* The next two are undocumented ! */
		case EM_GETTHUMB16:
			ret = (lc > 1) ? MAKELONG(fv * 100 / (lc - 1), 0) : 0;
			break;
		case EM_LINESCROLL16:
			dy = (INT16)LOWORD(lParam);
			break;
		case SB_ENDSCROLL:
			/* nothing to do */
		}
	}
	if (dy) {
		EDIT_EM_LineScroll(wndPtr, 0, dy);
		if (not) {
			dprintf_edit(stddeb, "edit: notification EN_VSCROLL sent\n");
			EDIT_NOTIFY_PARENT(wndPtr, EN_VSCROLL);
		}
	}
	return ret;
}