Release 970112
Sat Jan 11 18:17:59 1997 Alexandre Julliard <julliard@lrc.epfl.ch>
* [controls/menu.c]
Updated to new Win32 types.
* [controls/listbox.c]
Fixed Winfile extended selection bug.
* [files/directory.c]
Changed DIR_SearchPath to return both long and short file names.
* [files/dos_fs.c]
Implemented VFAT ioctl to retrieve the original short filenames
from a VFAT filesystem (Linux only for now).
Replaced DOSFS_GetUnixFileName()/DOSFS_GetDosTrueName() by
DOS_GetFullName().
Properly implemented GetShortPathName() and GetFullPathName().
Made all functions re-entrant.
* [files/file.c] [misc/main.c]
Replaced -allowreadonly option by -failreadonly. The default is
now to report success when opening a read-only file for writing.
* [objects/metafile.c]
Fixed bug in DIB bitmaps pointer calculation.
* [scheduler/process.c]
Implemented environment strings and Get/SetStdHandle with process
environment block.
* [tools/build.c]
Rewrote BuildContext32() to avoid instructions that may not be
supported by all assemblers.
Fri Jan 10 17:11:09 1997 David Faure <david.faure@ifhamy.insa-lyon.fr>
* [windows/event.c]
Created table keyc2vkey, which associate a vkey(+extended bit) to
any keycode. Changed EVENT_event_to_vkey to use this table to
return the correct vkey. Changed EVENT_ToAscii to get the keycode
from this table too. Assigned OEM specific vkeys arbitrarily.
Fri Jan 10 09:26:17 1997 John Harvey <john@division.co.uk>
* [misc/winsock.c] [misc/winsoc_async.c]
Fixed svr4 header files.
Changed bzero() to memset().
* [tools/fnt2bdf.c]
Removed bcopy() and used memcpy() instead.
* [debugger/msc.c]
Include string.h instead of strings.h
* [debugger/stabs.c]
Include string.h instead of strings.h.
Define __ELF__ for svr4 systems.
* [loader/signal.c]
Use wait() instead of wait4() which doesnt exist on Unixware.
* [memory/global.c]
Use sysconf() instead of getpagesize() for svr4 systems.
Thu Jan 9 21:07:20 1997 Robert Pouliot <krynos@clic.net>
* [Make.rules.in] [Makefile.in] [make_os2.sh] [rc/Makefile.in]
[tools/Makefile.in] [documentation/wine_os2.txt]
Patches for OS/2 support. Note that it doesn't compile yet.
Tue Jan 7 20:03:53 1997 Eric Youngdale <eric@sub2304.jic.com>
* [debugger/*]
Many more debugger improvements (see debugger/README for details).
Tue Jan 7 15:12:21 1997 Marcus Meissner <msmeissn@cip.informatik.uni-erlangen.de>
* [windows/graphics.c] [objects/text.c] [graphics/x11drv/*]
[graphics/metafiledrv/*]
Moved some device dependent code into the resp. subdirs.
* [include/gdi.h] [include/metafiledrv.h] [include/x11drv.h]
Prototypes added,
DC_FUNCTIONS: GetPixel added, some unnecessary functions removed.
* [objects/region.c]
CreatePolyPolygonRgn32 added.
* [files/dos_fs.c]
QueryDosDevice added.
* [misc/lstr.c]
FormatMessage: broken heap management fixed.
* [scheduler/process.c] [scheduler/thread.c]
Get/SetThreadPriority/PriorityClass added.
Mon Jan 6 21:55:30 1997 Philippe De Muyter <phdm@info.ucl.ac.be>
* [misc/keyboard.c]
ToAscii : Use EVENT_ToAscii instead.
* [windows/event.c]
keypad_key : Do not convert XK_Mode_switch to VK_MENU; recognize
keypad cursor keys.
EVENT_event_to_vkey : New function, to transform a X keycode
into a MSwin vkey + extended bit.
EVENT_ToAscii : New function, to transform a vkey + extended bit
(+ key state table) into ascii char(s), using XLookupString, and
recognizing dead chars.
EVENT_key : Transform AltGr into Ctrl+Alt sequence; call
EVENT_event_to_vkey for keycode to vkey conversion; fixed
previous, context and extended bits.
* [windows/keyboard.c]
Include stddebug.h, to get -debugmsg messages.
GetKeyState : Handle VK_MBUTTON case.
GetKeyboardState, SetKeyboardState : Debugging messages added.
* [windows/message.c]
TranslateMessage : Handle dead chars.
Mon Jan 6 20:10:11 1997 Dominik Strasser <bm424953@muenchen.org>
* [if1632/crtdll.spec] [misc/crtdll.c]
C++ functions new/delete/set_new_handler implemented.
Mon Jan 6 15:48:15 1997 Frans van Dorsselaer <dorssel@rulhmpc49.LeidenUniv.nl>
* [controls/edit.c] [include/windows.h]
Moved the edit control to 32 bits.
Included new (win95) message definitions in windows.h
Implemented EM_SCROLLCARET, EM_SETMARGINS, EM_GETMARGINS,
EM_GETLIMITTEXT, EM_POSFROMCHAR, EM_CHARFROMPOS.
Broke EM_SETWORDBREAKPROC (internal wordwrap still works).
Fixed some bugs, introduced a couple of others.
Text buffer is now initially in 32-bit heap.
* [controls/EDIT.TODO] [controls/combo.c] [controls/widgets.c]
[if1632/wprocs.spec] [library/miscstubs.c] [windows/defdlg.c]
[misc/commdlg.c]
Updated to work with 32-bit edit control.
Sat Jan 4 22:07:27 1997 O.Flebbe <O.Flebbe@science-computing.uni-tuebingen.de>
* [loader/pe_image.c]
Use mmap rather then malloc. Better workaround for clean
segments.
diff --git a/controls/edit.c b/controls/edit.c
index 3cb1372..e53103e 100644
--- a/controls/edit.c
+++ b/controls/edit.c
@@ -3,14 +3,18 @@
*
* Copyright David W. Metcalfe, 1994
* Copyright William Magro, 1995, 1996
- * Copyright Frans van Dorsselaer, 1996
+ * Copyright Frans van Dorsselaer, 1996, 1997
*
*/
/*
- * UNDER CONSTRUCTION, please read EDIT.TODO
+ * please read EDIT.TODO (and update it when you change things)
+ * It also contains a discussion about the 16 to 32 bit transition.
+ *
*/
+
+#define NO_TRANSITION_TYPES /* This file is Win32-clean */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
@@ -20,9 +24,12 @@
#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 */
@@ -39,38 +46,73 @@
} LINE_END;
typedef struct {
- UINT offset;
- UINT length;
+ INT32 offset;
+ INT32 length;
LINE_END ending;
} LINEDEF;
typedef struct
{
- UINT TextWidth; /* width of the widest line in pixels */
- HLOCAL16 hBuf;
- char *text;
- HFONT16 hFont;
- LINEDEF *LineDefs;
- UINT XOffset; /* offset of the viewport in pixels */
- UINT FirstVisibleLine;
- UINT LineCount;
- UINT LineHeight; /* height of a screen line in pixels */
- UINT AveCharWidth; /* average character width in pixels */
- UINT BufLimit;
- UINT BufSize;
- BOOL TextChanged;
- BOOL Redraw;
- UINT SelStart; /* offset of selection start, == SelEnd if no selection */
- UINT SelEnd; /* offset of selection end == current caret position */
- UINT NumTabStops;
+ 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;
+ BOOL32 TextChanged;
+ BOOL32 CanUndo;
+ BOOL32 Redraw;
+ INT32 SelStart; /* offset of selection start, == SelEnd if no selection */
+ INT32 SelEnd; /* offset of selection end == current caret position */
+ INT32 NumTabStops;
LPINT16 TabStops;
- EDITWORDBREAKPROC WordBreakProc;
- char PasswordChar;
+ /*
+ * 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_UINT(x,y) do { UINT temp = (UINT)(x); (x) = (UINT)(y); (y) = temp; } while(0)
-#define ORDER_UINT(x,y) do { if ((UINT)(y) < (UINT)(x)) SWAP_UINT((x),(y)); } while(0)
+#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)
@@ -86,15 +128,19 @@
#define EDIT_SEND_CTLCOLOR(wndPtr,hdc) \
(SendMessage32A((wndPtr)->parent->hwndSelf, WM_CTLCOLOREDIT, \
- (WPARAM32)(hdc), (LPARAM)(wndPtr)->hwndSelf ))
+ (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_MSG(str) \
+ MAKEWPARAM((wndPtr)->wIDmenu, wNotifyCode), \
+ (LPARAM)(wndPtr)->hwndSelf ))
+#define DPRINTF_EDIT_MSG16(str) \
dprintf_edit(stddeb, \
- "edit: " str ": hwnd=%04x, wParam=%04x, lParam=%08x\n", \
- (UINT32)hwnd, (UINT32)wParam, (UINT32)lParam)
+ "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)
/*********************************************************************
@@ -104,76 +150,84 @@
* Files like these should really be kept in alphabetical order.
*
*/
-LRESULT EditWndProc(HWND hwnd, UINT msg, WPARAM16 wParam, LPARAM lParam);
+LRESULT EditWndProc(HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam);
static void EDIT_BuildLineDefs(WND *wndPtr);
-static INT EDIT_CallWordBreakProc(WND *wndPtr, char *s, INT index, INT count, INT action);
-static UINT EDIT_ColFromWndX(WND *wndPtr, UINT line, INT x);
+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 UINT EDIT_GetAveCharWidth(WND *wndPtr);
-static UINT EDIT_GetLineHeight(WND *wndPtr);
-static void EDIT_GetLineRect(WND *wndPtr, UINT line, UINT scol, UINT ecol, LPRECT16 rc);
-static char * EDIT_GetPointer(WND *wndPtr);
-static char * EDIT_GetPasswordPointer(WND *wndPtr);
-static LRESULT EDIT_GetRect(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
-static BOOL EDIT_GetRedraw(WND *wndPtr);
-static LRESULT EDIT_GetSel(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
-static UINT EDIT_GetTextWidth(WND *wndPtr);
-static UINT EDIT_GetVisibleLineCount(WND *wndPtr);
-static UINT EDIT_GetWndWidth(WND *wndPtr);
-static UINT EDIT_GetXOffset(WND *wndPtr);
-static void EDIT_InvalidateText(WND *wndPtr, UINT start, UINT end);
-static UINT EDIT_LineFromWndY(WND *wndPtr, INT y);
-static BOOL EDIT_MakeFit(WND *wndPtr, UINT size);
-static void EDIT_MoveBackward(WND *wndPtr, BOOL extend);
-static void EDIT_MoveDownward(WND *wndPtr, BOOL extend);
-static void EDIT_MoveEnd(WND *wndPtr, BOOL extend);
-static void EDIT_MoveForward(WND *wndPtr, BOOL extend);
-static void EDIT_MoveHome(WND *wndPtr, BOOL extend);
-static void EDIT_MovePageDown(WND *wndPtr, BOOL extend);
-static void EDIT_MovePageUp(WND *wndPtr, BOOL extend);
-static void EDIT_MoveUpward(WND *wndPtr, BOOL extend);
-static void EDIT_MoveWordBackward(WND *wndPtr, BOOL extend);
-static void EDIT_MoveWordForward(WND *wndPtr, BOOL extend);
-static void EDIT_PaintLine(WND *wndPtr, HDC32 hdc, UINT line, BOOL rev);
-static UINT EDIT_PaintText(WND *wndPtr, HDC32 hdc, INT x, INT y, UINT line, UINT col, UINT count, BOOL rev);
+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 BOOL32 EDIT_GetRedraw(WND *wndPtr);
+static void EDIT_GetSel(WND *wndPtr, LPINT32 s, LPINT32 e);
+static INT32 EDIT_GetTextWidth(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 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 LRESULT EDIT_ReplaceSel(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
-static void EDIT_ScrollIntoView(WND *wndPtr);
-static INT EDIT_WndXFromCol(WND *wndPtr, UINT line, UINT col);
-static INT EDIT_WndYFromLine(WND *wndPtr, UINT line);
-static INT EDIT_WordBreakProc(char *s, INT index, INT count, INT action);
+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, WPARAM32 wParam, LPARAM lParam);
+static LRESULT EDIT_EM_CharFromPos(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_EmptyUndoBuffer(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_FmtLines(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_GetFirstVisibleLine(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_GetHandle(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
+static LRESULT EDIT_EM_GetHandle16(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
+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, WPARAM32 wParam, LPARAM lParam);
+static LRESULT EDIT_EM_GetMargins(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_GetModify(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_GetPasswordChar(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
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, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_GetWordBreakProc(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
-static LRESULT EDIT_EM_LimitText(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_LineFromChar(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_LineIndex(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_LineLength(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_LineScroll(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
+static LRESULT EDIT_EM_PosFromChar(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_ReplaceSel(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_Scroll(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
+static LRESULT EDIT_EM_ScrollCaret(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_SetHandle(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
+static LRESULT EDIT_EM_SetHandle16(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
+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, LPARAM lParam);
static LRESULT EDIT_EM_SetPasswordChar(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
static LRESULT EDIT_EM_SetReadOnly(WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
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, WPARAM32 wParam, LPARAM lParam);
@@ -211,22 +265,22 @@
*
* General shortcuts for variable names:
*
- * UINT l; line
- * UINT c; column
- * UINT s; offset of selection start
- * UINT e; offset of selection end
- * UINT sl; line on which the selection starts
- * UINT el; line on which the selection ends
- * UINT sc; column on which the selection starts
- * UINT ec; column on which the selection ends
- * UINT li; line index (offset)
- * UINT fv; first visible line
- * UINT vlc; vissible line count
- * UINT lc; line count
- * UINT lh; line height (in pixels)
- * UINT tw; text width (in pixels)
- * UINT ww; window width (in pixels)
- * UINT cw; character width (average, in pixels)
+ * 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)
*
*/
@@ -235,255 +289,496 @@
*
* 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(HWND hwnd, UINT msg, WPARAM16 wParam, LPARAM lParam)
+LRESULT EditWndProc(HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam)
{
- LRESULT lResult = 0L;
+ LRESULT lResult = 0;
WND *wndPtr = WIN_FindWndPtr(hwnd);
if ((!EDITSTATEPTR(wndPtr)) && (msg != WM_CREATE))
- return DefWindowProc16(hwnd, msg, wParam, lParam);
+ return DefWindowProc32A(hwnd, msg, wParam, lParam);
switch (msg) {
- case EM_CANUNDO:
- DPRINTF_EDIT_MSG("EM_CANUNDO");
- lResult = EDIT_EM_CanUndo(wndPtr, wParam, lParam);
- break;
- case EM_EMPTYUNDOBUFFER:
- DPRINTF_EDIT_MSG("EM_EMPTYUNDOBUFFER");
- lResult = EDIT_EM_EmptyUndoBuffer(wndPtr, wParam, lParam);
- break;
- case EM_FMTLINES:
- DPRINTF_EDIT_MSG("EM_FMTLINES");
- lResult = EDIT_EM_FmtLines(wndPtr, wParam, lParam);
- break;
- case EM_GETFIRSTVISIBLELINE:
- DPRINTF_EDIT_MSG("EM_GETFIRSTVISIBLELINE");
- lResult = EDIT_EM_GetFirstVisibleLine(wndPtr, wParam, lParam);
- break;
- case EM_GETHANDLE:
- DPRINTF_EDIT_MSG("EM_GETHANDLE");
- lResult = EDIT_EM_GetHandle(wndPtr, wParam, lParam);
- break;
- case EM_GETLINE:
- DPRINTF_EDIT_MSG("EM_GETLINE");
- lResult = EDIT_EM_GetLine(wndPtr, wParam, lParam);
- break;
- case EM_GETLINECOUNT:
- DPRINTF_EDIT_MSG("EM_GETLINECOUNT");
- lResult = EDIT_EM_GetLineCount(wndPtr, wParam, lParam);
- break;
- case EM_GETMODIFY:
- DPRINTF_EDIT_MSG("EM_GETMODIFY");
- lResult = EDIT_EM_GetModify(wndPtr, wParam, lParam);
- break;
- case EM_GETPASSWORDCHAR:
- DPRINTF_EDIT_MSG("EM_GETPASSWORDCHAR");
- lResult = EDIT_EM_GetPasswordChar(wndPtr, wParam, lParam);
- break;
- case EM_GETRECT:
- DPRINTF_EDIT_MSG("EM_GETRECT");
- lResult = EDIT_EM_GetRect(wndPtr, wParam, lParam);
- break;
- case EM_GETSEL:
- DPRINTF_EDIT_MSG("EM_GETSEL");
+ 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_GETTHUMB:
- DPRINTF_EDIT_MSG("EM_GETTHUMB");
- lResult = EDIT_EM_GetThumb(wndPtr, wParam, lParam);
+
+ case EM_SETSEL16:
+ DPRINTF_EDIT_MSG16("EM_SETSEL");
+ lResult = EDIT_EM_SetSel16(wndPtr, wParam, lParam);
break;
- case EM_GETWORDBREAKPROC:
- DPRINTF_EDIT_MSG("EM_GETWORDBREAKPROC");
- lResult = EDIT_EM_GetWordBreakProc(wndPtr, wParam, lParam);
- break;
- case EM_LIMITTEXT:
- DPRINTF_EDIT_MSG("EM_LIMITTEXT");
- lResult = EDIT_EM_LimitText(wndPtr, wParam, lParam);
- break;
- case EM_LINEFROMCHAR:
- DPRINTF_EDIT_MSG("EM_LINEFROMCHAR");
- lResult = EDIT_EM_LineFromChar(wndPtr, wParam, lParam);
- break;
- case EM_LINEINDEX:
- DPRINTF_EDIT_MSG("EM_LINEINDEX");
- lResult = EDIT_EM_LineIndex(wndPtr, wParam, lParam);
- break;
- case EM_LINELENGTH:
- DPRINTF_EDIT_MSG("EM_LINELENGTH");
- lResult = EDIT_EM_LineLength(wndPtr, wParam, lParam);
- break;
- case EM_LINESCROLL:
- DPRINTF_EDIT_MSG("EM_LINESCROLL");
- lResult = EDIT_EM_LineScroll(wndPtr, wParam, lParam);
- break;
- case EM_REPLACESEL:
- DPRINTF_EDIT_MSG("EM_REPLACESEL");
- lResult = EDIT_EM_ReplaceSel(wndPtr, wParam, lParam);
- break;
- case EM_SCROLL:
- DPRINTF_EDIT_MSG("EM_SCROLL");
- lResult = EDIT_EM_Scroll(wndPtr, wParam, lParam);
- break;
- case EM_SETHANDLE:
- DPRINTF_EDIT_MSG("EM_SETHANDLE");
- lResult = EDIT_EM_SetHandle(wndPtr, wParam, lParam);
- break;
- case EM_SETMODIFY:
- DPRINTF_EDIT_MSG("EM_SETMODIFY");
- lResult = EDIT_EM_SetModify(wndPtr, wParam, lParam);
- break;
- case EM_SETPASSWORDCHAR:
- DPRINTF_EDIT_MSG("EM_SETPASSWORDCHAR");
- lResult = EDIT_EM_SetPasswordChar(wndPtr, wParam, lParam);
- break;
- case EM_SETREADONLY:
- DPRINTF_EDIT_MSG("EM_SETREADONLY");
- lResult = EDIT_EM_SetReadOnly(wndPtr, wParam, lParam);
- break;
- case EM_SETRECT:
- DPRINTF_EDIT_MSG("EM_SETRECT");
- lResult = EDIT_EM_SetRect(wndPtr, wParam, lParam);
- break;
- case EM_SETRECTNP:
- DPRINTF_EDIT_MSG("EM_SETRECTNP");
- lResult = EDIT_EM_SetRectNP(wndPtr, wParam, lParam);
- break;
- case EM_SETSEL:
- DPRINTF_EDIT_MSG("EM_SETSEL");
+ case EM_SETSEL32:
+ DPRINTF_EDIT_MSG32("EM_SETSEL");
lResult = EDIT_EM_SetSel(wndPtr, wParam, lParam);
break;
- case EM_SETTABSTOPS:
- DPRINTF_EDIT_MSG("EM_SETTABSTOPS");
- lResult = EDIT_EM_SetTabStops(wndPtr, wParam, lParam);
+
+ case EM_GETRECT16:
+ DPRINTF_EDIT_MSG16("EM_GETRECT");
+ lResult = EDIT_EM_GetRect16(wndPtr, wParam, lParam);
break;
- case EM_SETWORDBREAKPROC:
- DPRINTF_EDIT_MSG("EM_SETWORDBREAKPROC");
- lResult = EDIT_EM_SetWordBreakProc(wndPtr, wParam, lParam);
+ case EM_GETRECT32:
+ DPRINTF_EDIT_MSG32("EM_GETRECT");
+ lResult = EDIT_EM_GetRect(wndPtr, wParam, lParam);
break;
- case EM_UNDO:
+
+ 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, lParam);
+ 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, wParam, lParam);
+ break;
+
+ case EM_GETMODIFY16:
+ DPRINTF_EDIT_MSG16("EM_GETMODIFY");
+ /* fall through */
+ case EM_GETMODIFY32:
+ DPRINTF_EDIT_MSG32("EM_GETMODIFY");
+ lResult = EDIT_EM_GetModify(wndPtr, wParam, lParam);
+ 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, lParam);
+ break;
+
+ case EM_GETLINECOUNT16:
+ DPRINTF_EDIT_MSG16("EM_GETLINECOUNT");
+ /* fall through */
+ case EM_GETLINECOUNT32:
+ DPRINTF_EDIT_MSG32("EM_GETLINECOUNT");
+ lResult = EDIT_EM_GetLineCount(wndPtr, wParam, lParam);
+ 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, lParam);
+ break;
+
+ case EM_SETHANDLE16:
+ DPRINTF_EDIT_MSG16("EM_SETHANDLE");
+ lResult = EDIT_EM_SetHandle16(wndPtr, wParam, lParam);
+ break;
+ case EM_SETHANDLE32:
+ DPRINTF_EDIT_MSG32("EM_SETHANDLE");
+ lResult = EDIT_EM_SetHandle(wndPtr, wParam, lParam);
+ break;
+
+ case EM_GETHANDLE16:
+ DPRINTF_EDIT_MSG16("EM_GETHANDLE");
+ lResult = EDIT_EM_GetHandle16(wndPtr, wParam, lParam);
+ break;
+ case EM_GETHANDLE32:
+ DPRINTF_EDIT_MSG32("EM_GETHANDLE");
+ lResult = EDIT_EM_GetHandle(wndPtr, wParam, lParam);
+ break;
+
+ case EM_GETTHUMB16:
+ DPRINTF_EDIT_MSG16("EM_GETTHUMB");
+ /* fall through */
+ case EM_GETTHUMB32:
+ DPRINTF_EDIT_MSG32("EM_GETTHUMB");
+ lResult = EDIT_EM_GetThumb(wndPtr, wParam, lParam);
+ 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, lParam);
+ 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, wParam, lParam);
+ break;
+
+ case EM_UNDO16:
+ DPRINTF_EDIT_MSG16("EM_UNDO");
+ /* fall through */
+ case EM_UNDO32:
+ /* fall through */
case WM_UNDO:
- DPRINTF_EDIT_MSG("EM_UNDO / WM_UNDO");
+ DPRINTF_EDIT_MSG32("EM_UNDO / WM_UNDO");
lResult = EDIT_EM_Undo(wndPtr, wParam, lParam);
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, lParam);
+ 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, lParam);
+ 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, lParam);
+ break;
+
+ case EM_EMPTYUNDOBUFFER16:
+ DPRINTF_EDIT_MSG16("EM_EMPTYUNDOBUFFER");
+ /* fall through */
+ case EM_EMPTYUNDOBUFFER32:
+ DPRINTF_EDIT_MSG32("EM_EMPTYUNDOBUFFER");
+ lResult = EDIT_EM_EmptyUndoBuffer(wndPtr, wParam, lParam);
+ break;
+
+ case EM_GETFIRSTVISIBLELINE16:
+ DPRINTF_EDIT_MSG16("EM_GETFIRSTVISIBLELINE");
+ /* fall through */
+ case EM_GETFIRSTVISIBLELINE32:
+ DPRINTF_EDIT_MSG32("EM_GETFIRSTVISIBLELINE");
+ lResult = EDIT_EM_GetFirstVisibleLine(wndPtr, wParam, lParam);
+ 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, lParam);
+ 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, wParam, lParam);
+ 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, lParam);
+ break;
+
+ case EM_CHARFROMPOS32:
+ DPRINTF_EDIT_MSG16("EM_CHARFROMPOS");
+ lResult = EDIT_EM_CharFromPos(wndPtr, wParam, lParam);
+ break;
+
case WM_GETDLGCODE:
- DPRINTF_EDIT_MSG("WM_GETDLGCODE");
+ DPRINTF_EDIT_MSG32("WM_GETDLGCODE");
lResult = EDIT_WM_GetDlgCode(wndPtr, wParam, lParam);
break;
+
case WM_CHAR:
- DPRINTF_EDIT_MSG("WM_CHAR");
+ DPRINTF_EDIT_MSG32("WM_CHAR");
lResult = EDIT_WM_Char(wndPtr, wParam, lParam);
break;
+
case WM_CLEAR:
- DPRINTF_EDIT_MSG("WM_CLEAR");
+ DPRINTF_EDIT_MSG32("WM_CLEAR");
lResult = EDIT_WM_Clear(wndPtr, wParam, lParam);
break;
+
case WM_COPY:
- DPRINTF_EDIT_MSG("WM_COPY");
+ DPRINTF_EDIT_MSG32("WM_COPY");
lResult = EDIT_WM_Copy(wndPtr, wParam, lParam);
break;
+
case WM_CREATE:
- DPRINTF_EDIT_MSG("WM_CREATE");
+ DPRINTF_EDIT_MSG32("WM_CREATE");
lResult = EDIT_WM_Create(wndPtr, wParam, lParam);
break;
+
case WM_CUT:
- DPRINTF_EDIT_MSG("WM_CUT");
+ DPRINTF_EDIT_MSG32("WM_CUT");
lResult = EDIT_WM_Cut(wndPtr, wParam, lParam);
break;
+
case WM_DESTROY:
- DPRINTF_EDIT_MSG("WM_DESTROY");
+ DPRINTF_EDIT_MSG32("WM_DESTROY");
lResult = EDIT_WM_Destroy(wndPtr, wParam, lParam);
break;
+
case WM_ENABLE:
- DPRINTF_EDIT_MSG("WM_ENABLE");
+ DPRINTF_EDIT_MSG32("WM_ENABLE");
lResult = EDIT_WM_Enable(wndPtr, wParam, lParam);
break;
+
case WM_ERASEBKGND:
- DPRINTF_EDIT_MSG("WM_ERASEBKGND");
+ DPRINTF_EDIT_MSG32("WM_ERASEBKGND");
lResult = EDIT_WM_EraseBkGnd(wndPtr, wParam, lParam);
break;
+
case WM_GETFONT:
- DPRINTF_EDIT_MSG("WM_GETFONT");
+ DPRINTF_EDIT_MSG32("WM_GETFONT");
lResult = EDIT_WM_GetFont(wndPtr, wParam, lParam);
break;
+
case WM_GETTEXT:
- DPRINTF_EDIT_MSG("WM_GETTEXT");
+ DPRINTF_EDIT_MSG32("WM_GETTEXT");
lResult = EDIT_WM_GetText(wndPtr, wParam, lParam);
break;
+
case WM_GETTEXTLENGTH:
- DPRINTF_EDIT_MSG("WM_GETTEXTLENGTH");
+ DPRINTF_EDIT_MSG32("WM_GETTEXTLENGTH");
lResult = EDIT_WM_GetTextLength(wndPtr, wParam, lParam);
break;
+
case WM_HSCROLL:
- DPRINTF_EDIT_MSG("WM_HSCROLL");
+ DPRINTF_EDIT_MSG32("WM_HSCROLL");
lResult = EDIT_WM_HScroll(wndPtr, wParam, lParam);
break;
+
case WM_KEYDOWN:
- DPRINTF_EDIT_MSG("WM_KEYDOWN");
+ DPRINTF_EDIT_MSG32("WM_KEYDOWN");
lResult = EDIT_WM_KeyDown(wndPtr, wParam, lParam);
break;
+
case WM_KILLFOCUS:
- DPRINTF_EDIT_MSG("WM_KILLFOCUS");
+ DPRINTF_EDIT_MSG32("WM_KILLFOCUS");
lResult = EDIT_WM_KillFocus(wndPtr, wParam, lParam);
break;
+
case WM_LBUTTONDBLCLK:
- DPRINTF_EDIT_MSG("WM_LBUTTONDBLCLK");
+ DPRINTF_EDIT_MSG32("WM_LBUTTONDBLCLK");
lResult = EDIT_WM_LButtonDblClk(wndPtr, wParam, lParam);
break;
+
case WM_LBUTTONDOWN:
- DPRINTF_EDIT_MSG("WM_LBUTTONDOWN");
+ DPRINTF_EDIT_MSG32("WM_LBUTTONDOWN");
lResult = EDIT_WM_LButtonDown(wndPtr, wParam, lParam);
break;
+
case WM_LBUTTONUP:
- DPRINTF_EDIT_MSG("WM_LBUTTONUP");
+ DPRINTF_EDIT_MSG32("WM_LBUTTONUP");
lResult = EDIT_WM_LButtonUp(wndPtr, wParam, lParam);
break;
+
case WM_MOUSEMOVE:
/*
- * DPRINTF_EDIT_MSG("WM_MOUSEMOVE");
+ * DPRINTF_EDIT_MSG32("WM_MOUSEMOVE");
*/
lResult = EDIT_WM_MouseMove(wndPtr, wParam, lParam);
break;
+
case WM_PAINT:
- DPRINTF_EDIT_MSG("WM_PAINT");
+ DPRINTF_EDIT_MSG32("WM_PAINT");
lResult = EDIT_WM_Paint(wndPtr, wParam, lParam);
break;
+
case WM_PASTE:
- DPRINTF_EDIT_MSG("WM_PASTE");
+ DPRINTF_EDIT_MSG32("WM_PASTE");
lResult = EDIT_WM_Paste(wndPtr, wParam, lParam);
break;
+
case WM_SETCURSOR:
/*
- * DPRINTF_EDIT_MSG("WM_SETCURSOR");
+ * DPRINTF_EDIT_MSG32("WM_SETCURSOR");
*/
lResult = EDIT_WM_SetCursor(wndPtr, wParam, lParam);
break;
+
case WM_SETFOCUS:
- DPRINTF_EDIT_MSG("WM_SETFOCUS");
+ DPRINTF_EDIT_MSG32("WM_SETFOCUS");
lResult = EDIT_WM_SetFocus(wndPtr, wParam, lParam);
break;
+
case WM_SETFONT:
- DPRINTF_EDIT_MSG("WM_SETFONT");
+ DPRINTF_EDIT_MSG32("WM_SETFONT");
lResult = EDIT_WM_SetFont(wndPtr, wParam, lParam);
break;
+
case WM_SETREDRAW:
- DPRINTF_EDIT_MSG("WM_SETREDRAW");
+ DPRINTF_EDIT_MSG32("WM_SETREDRAW");
lResult = EDIT_WM_SetRedraw(wndPtr, wParam, lParam);
break;
+
case WM_SETTEXT:
- DPRINTF_EDIT_MSG("WM_SETTEXT");
+ DPRINTF_EDIT_MSG32("WM_SETTEXT");
lResult = EDIT_WM_SetText(wndPtr, wParam, lParam);
break;
+
case WM_SIZE:
- DPRINTF_EDIT_MSG("WM_SIZE");
+ DPRINTF_EDIT_MSG32("WM_SIZE");
lResult = EDIT_WM_Size(wndPtr, wParam, lParam);
break;
+
case WM_VSCROLL:
- DPRINTF_EDIT_MSG("WM_VSCROLL");
+ DPRINTF_EDIT_MSG32("WM_VSCROLL");
lResult = EDIT_WM_VScroll(wndPtr, wParam, lParam);
break;
+
default:
- lResult = DefWindowProc16(hwnd, msg, wParam, lParam);
+ lResult = DefWindowProc32A(hwnd, msg, wParam, lParam);
break;
}
EDIT_ReleasePointer(wndPtr);
@@ -503,28 +798,28 @@
static void EDIT_BuildLineDefs(WND *wndPtr)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
- char *text = EDIT_GetPasswordPointer(wndPtr);
- int ww = EDIT_GetWndWidth(wndPtr);
+ LPSTR text = EDIT_GetPasswordPointer(wndPtr);
+ INT32 ww = EDIT_GetWndWidth(wndPtr);
HDC32 hdc;
- HFONT16 hFont;
+ HFONT32 hFont;
HFONT32 oldFont = 0;
- char *start, *cp;
- int prev, next;
- int width;
- int length;
+ LPSTR start, cp;
+ INT32 prev, next;
+ INT32 width;
+ INT32 length;
LINE_END ending;
hdc = GetDC32(wndPtr->hwndSelf);
- hFont = (HFONT16)EDIT_WM_GetFont(wndPtr, 0, 0L);
+ hFont = (HFONT32)EDIT_WM_GetFont(wndPtr, 0, 0);
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, 0, 0L);
+ es->LineDefs[0].length = EDIT_WM_GetTextLength(wndPtr, 0, 0);
es->LineDefs[0].ending = END_0;
- es->TextWidth = LOWORD(GetTabbedTextExtent(hdc, text,
+ es->TextWidth = (INT32)LOWORD(GetTabbedTextExtent(hdc, text,
es->LineDefs[0].length,
es->NumTabStops, es->TabStops));
} else {
@@ -533,7 +828,7 @@
do {
if (!(cp = strstr(start, "\r\n"))) {
ending = END_0;
- length = strlen(start);
+ length = lstrlen32A(start);
} else if ((cp > start) && (*(cp - 1) == '\r')) {
ending = END_SOFT;
length = cp - start - 1;
@@ -541,7 +836,7 @@
ending = END_HARD;
length = cp - start;
}
- width = LOWORD(GetTabbedTextExtent(hdc, start, length,
+ width = (INT32)LOWORD(GetTabbedTextExtent(hdc, start, length,
es->NumTabStops, es->TabStops));
if (IsWordWrap(wndPtr) && (width > ww)) {
@@ -550,7 +845,7 @@
prev = next;
next = EDIT_CallWordBreakProc(wndPtr, start,
prev + 1, length, WB_RIGHT);
- width = LOWORD(GetTabbedTextExtent(hdc, start, next,
+ width = (INT32)LOWORD(GetTabbedTextExtent(hdc, start, next,
es->NumTabStops, es->TabStops));
} while (width <= ww);
if (!prev) {
@@ -558,7 +853,7 @@
do {
prev = next;
next++;
- width = LOWORD(GetTabbedTextExtent(hdc, start, next,
+ width = (INT32)LOWORD(GetTabbedTextExtent(hdc, start, next,
es->NumTabStops, es->TabStops));
} while (width <= ww);
if(!prev) prev = 1;
@@ -570,7 +865,7 @@
ending = END_DELIMIT;
} else
ending = END_NONE;
- width = LOWORD(GetTabbedTextExtent(hdc, start, length,
+ width = (INT32)LOWORD(GetTabbedTextExtent(hdc, start, length,
es->NumTabStops, es->TabStops));
}
@@ -610,24 +905,28 @@
*
* 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 INT EDIT_CallWordBreakProc(WND *wndPtr, char *s, INT index, INT count, INT action)
+static INT32 EDIT_CallWordBreakProc(WND *wndPtr, LPSTR s, INT32 index, INT32 count, INT32 action)
{
- EDITWORDBREAKPROC wbp = (EDITWORDBREAKPROC)EDIT_EM_GetWordBreakProc(wndPtr, 0, 0L);
-
- if (!wbp) return EDIT_WordBreakProc(s, index, count, action);
- else
- {
- /* We need a SEGPTR here */
-
- EDITSTATE *es = EDITSTATEPTR(wndPtr);
- SEGPTR ptr = LOCAL_LockSegptr( wndPtr->hInstance, es->hBuf ) +
- (UINT16)(s - EDIT_GetPointer(wndPtr));
- INT ret = CallWordBreakProc( (FARPROC16)wbp, ptr,
- index, count, action);
- LOCAL_Unlock( wndPtr->hInstance, es->hBuf );
- return ret;
- }
+ 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;
+ * }
+ */
}
@@ -638,12 +937,12 @@
* Calculates, for a given line and X-coordinate on the screen, the column.
*
*/
-static UINT EDIT_ColFromWndX(WND *wndPtr, UINT line, INT x)
-{
- UINT lc = (UINT)EDIT_EM_GetLineCount(wndPtr, 0, 0L);
- UINT li = (UINT)EDIT_EM_LineIndex(wndPtr, line, 0L);
- UINT ll = (UINT)EDIT_EM_LineLength(wndPtr, li, 0L);
- UINT i;
+static INT32 EDIT_ColFromWndX(WND *wndPtr, INT32 line, INT32 x)
+{
+ INT32 lc = (INT32)EDIT_EM_GetLineCount(wndPtr, 0, 0);
+ INT32 li = (INT32)EDIT_EM_LineIndex(wndPtr, line, 0);
+ INT32 ll = (INT32)EDIT_EM_LineLength(wndPtr, li, 0);
+ INT32 i;
line = MAX(0, MIN(line, lc - 1));
for (i = 0 ; i < ll ; i++)
@@ -662,9 +961,9 @@
*/
static void EDIT_DelEnd(WND *wndPtr)
{
- EDIT_EM_SetSel(wndPtr, 1, MAKELPARAM(-1, 0));
+ EDIT_EM_SetSel(wndPtr, -1, 0);
EDIT_MoveEnd(wndPtr, TRUE);
- EDIT_WM_Clear(wndPtr, 0, 0L);
+ EDIT_WM_Clear(wndPtr, 0, 0);
}
@@ -677,9 +976,9 @@
*/
static void EDIT_DelLeft(WND *wndPtr)
{
- EDIT_EM_SetSel(wndPtr, 1, MAKELPARAM(-1, 0));
+ EDIT_EM_SetSel(wndPtr, -1, 0);
EDIT_MoveBackward(wndPtr, TRUE);
- EDIT_WM_Clear(wndPtr, 0, 0L);
+ EDIT_WM_Clear(wndPtr, 0, 0);
}
@@ -692,9 +991,9 @@
*/
static void EDIT_DelRight(WND *wndPtr)
{
- EDIT_EM_SetSel(wndPtr, 1, MAKELPARAM(-1, 0));
+ EDIT_EM_SetSel(wndPtr, -1, 0);
EDIT_MoveForward(wndPtr, TRUE);
- EDIT_WM_Clear(wndPtr, 0, 0L);
+ EDIT_WM_Clear(wndPtr, 0, 0);
}
@@ -703,10 +1002,10 @@
* EDIT_GetAveCharWidth
*
*/
-static UINT EDIT_GetAveCharWidth(WND *wndPtr)
+static INT32 EDIT_GetAveCharWidth(WND *wndPtr)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
-
+
return es->AveCharWidth;
}
@@ -716,10 +1015,10 @@
* EDIT_GetLineHeight
*
*/
-static UINT EDIT_GetLineHeight(WND *wndPtr)
+static INT32 EDIT_GetLineHeight(WND *wndPtr)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
-
+
return es->LineHeight;
}
@@ -732,12 +1031,12 @@
* column to an ending column.
*
*/
-static void EDIT_GetLineRect(WND *wndPtr, UINT line, UINT scol, UINT ecol, LPRECT16 rc)
+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 = ((INT)ecol == -1) ? EDIT_GetWndWidth(wndPtr) :
+ rc->right = (ecol == -1) ? EDIT_GetWndWidth(wndPtr) :
EDIT_WndXFromCol(wndPtr, line, ecol);
}
@@ -750,12 +1049,16 @@
* you can call it whenever you like, without unlocking.
*
*/
-static char *EDIT_GetPointer(WND *wndPtr)
+static LPSTR EDIT_GetPointer(WND *wndPtr)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
-
- if (!es->text && es->hBuf)
- es->text = LOCAL_Lock(wndPtr->hInstance, es->hBuf);
+
+ 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;
}
@@ -766,11 +1069,11 @@
*
*
*/
-static char *EDIT_GetPasswordPointer(WND *wndPtr)
+static LPSTR EDIT_GetPasswordPointer(WND *wndPtr)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
- char *text = xstrdup(EDIT_GetPointer(wndPtr));
- char *p;
+ LPSTR text = xstrdup(EDIT_GetPointer(wndPtr));
+ LPSTR p;
if(es->PasswordChar) {
p = text;
@@ -786,26 +1089,10 @@
/*********************************************************************
*
- * EDIT_GetRect
- *
- * Beware: This is not the function called on EM_GETRECT.
- * It expects a (LPRECT) in lParam, not a (SEGPTR).
- * It is used internally, as if there were no pointer difficulties.
- *
- */
-static LRESULT EDIT_GetRect(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
-{
- GetClientRect16( wndPtr->hwndSelf, (LPRECT16)lParam );
- return 0L;
-}
-
-
-/*********************************************************************
- *
* EDIT_GetRedraw
*
*/
-static BOOL EDIT_GetRedraw(WND *wndPtr)
+static BOOL32 EDIT_GetRedraw(WND *wndPtr)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
@@ -818,26 +1105,29 @@
* EDIT_GetSel
*
* Beware: This is not the function called on EM_GETSEL.
- * It returns the start in the low word and the end in the high word.
- * NB s can be greater than e.
+ * (because s can be greater than e).
*
*/
-static LRESULT EDIT_GetSel(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+static void EDIT_GetSel(WND *wndPtr, LPINT32 s, LPINT32 e)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
- return MAKELONG(es->SelStart, es->SelEnd);
+ if (s)
+ *s = es->SelStart;
+ if (e)
+ *e = es->SelEnd;
}
+
/*********************************************************************
*
* EDIT_GetTextWidth
*
*/
-static UINT EDIT_GetTextWidth(WND *wndPtr)
+static INT32 EDIT_GetTextWidth(WND *wndPtr)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
-
+
return es->TextWidth;
}
@@ -847,11 +1137,11 @@
* EDIT_GetVisibleLineCount
*
*/
-static UINT EDIT_GetVisibleLineCount(WND *wndPtr)
+static INT32 EDIT_GetVisibleLineCount(WND *wndPtr)
{
- RECT16 rc;
-
- EDIT_GetRect(wndPtr, 0, (LPARAM)&rc);
+ RECT32 rc;
+
+ EDIT_EM_GetRect(wndPtr, 0, (LPARAM)&rc);
return MAX(1, MAX(rc.bottom - rc.top, 0) / EDIT_GetLineHeight(wndPtr));
}
@@ -861,11 +1151,11 @@
* EDIT_GetWndWidth
*
*/
-static UINT EDIT_GetWndWidth(WND *wndPtr)
+static INT32 EDIT_GetWndWidth(WND *wndPtr)
{
- RECT16 rc;
-
- EDIT_GetRect(wndPtr, 0, (LPARAM)&rc);
+ RECT32 rc;
+
+ EDIT_EM_GetRect(wndPtr, 0, (LPARAM)&rc);
return rc.right - rc.left;
}
@@ -875,10 +1165,10 @@
* EDIT_GetXOffset
*
*/
-static UINT EDIT_GetXOffset(WND *wndPtr)
+static INT32 EDIT_GetXOffset(WND *wndPtr)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
-
+
return es->XOffset;
}
@@ -894,64 +1184,64 @@
* start and end need not be ordered.
*
*/
-static void EDIT_InvalidateText(WND *wndPtr, UINT start, UINT end)
+static void EDIT_InvalidateText(WND *wndPtr, INT32 start, INT32 end)
{
- UINT fv = (UINT)EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0L);
- UINT vlc = EDIT_GetVisibleLineCount(wndPtr);
- UINT sl;
- UINT el;
- UINT sc;
- UINT ec;
- RECT16 rcWnd;
- RECT16 rcLine;
- RECT16 rcUpdate;
- UINT l;
+ INT32 fv = (INT32)EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0);
+ 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 ((INT)end == -1)
- end = (UINT)EDIT_WM_GetTextLength(wndPtr, 0, 0L);
- ORDER_UINT(start, end);
- sl = (UINT)EDIT_EM_LineFromChar(wndPtr, start, 0L);
- el = (UINT)EDIT_EM_LineFromChar(wndPtr, end, 0L);
+ if (end == -1)
+ end = (INT32)EDIT_WM_GetTextLength(wndPtr, 0, 0);
+ ORDER_INT32(start, end);
+ sl = (INT32)EDIT_EM_LineFromChar(wndPtr, start, 0);
+ el = (INT32)EDIT_EM_LineFromChar(wndPtr, end, 0);
if ((el < fv) || (sl > fv + vlc))
return;
- sc = start - (UINT)EDIT_EM_LineIndex(wndPtr, sl, 0L);
- ec = end - (UINT)EDIT_EM_LineIndex(wndPtr, el, 0L);
+ sc = start - (INT32)EDIT_EM_LineIndex(wndPtr, sl, 0);
+ ec = end - (INT32)EDIT_EM_LineIndex(wndPtr, el, 0);
if (sl < fv) {
sl = fv;
sc = 0;
}
if (el > fv + vlc) {
el = fv + vlc;
- ec = (UINT)EDIT_EM_LineLength(wndPtr,
- (UINT)EDIT_EM_LineIndex(wndPtr, el, 0L), 0L);
+ ec = (INT32)EDIT_EM_LineLength(wndPtr,
+ (INT32)EDIT_EM_LineIndex(wndPtr, el, 0), 0);
}
- EDIT_GetRect(wndPtr, 0, (LPARAM)&rcWnd);
+ EDIT_EM_GetRect(wndPtr, 0, (LPARAM)&rcWnd);
if (sl == el) {
EDIT_GetLineRect(wndPtr, sl, sc, ec, &rcLine);
- if (IntersectRect16(&rcUpdate, &rcWnd, &rcLine))
- InvalidateRect16( wndPtr->hwndSelf, &rcUpdate, FALSE );
+ if (IntersectRect32(&rcUpdate, &rcWnd, &rcLine))
+ InvalidateRect32( wndPtr->hwndSelf, &rcUpdate, FALSE );
} else {
EDIT_GetLineRect(wndPtr, sl, sc,
- (UINT)EDIT_EM_LineLength(wndPtr,
- (UINT)EDIT_EM_LineIndex(wndPtr, sl, 0L), 0L),
+ (INT32)EDIT_EM_LineLength(wndPtr,
+ (INT32)EDIT_EM_LineIndex(wndPtr, sl, 0), 0),
&rcLine);
- if (IntersectRect16(&rcUpdate, &rcWnd, &rcLine))
- InvalidateRect16( wndPtr->hwndSelf, &rcUpdate, FALSE );
+ if (IntersectRect32(&rcUpdate, &rcWnd, &rcLine))
+ InvalidateRect32( wndPtr->hwndSelf, &rcUpdate, FALSE );
for (l = sl + 1 ; l < el ; l++) {
EDIT_GetLineRect(wndPtr, l, 0,
- (UINT)EDIT_EM_LineLength(wndPtr,
- (UINT)EDIT_EM_LineIndex(wndPtr, l, 0L), 0L),
+ (INT32)EDIT_EM_LineLength(wndPtr,
+ (INT32)EDIT_EM_LineIndex(wndPtr, l, 0), 0),
&rcLine);
- if (IntersectRect16(&rcUpdate, &rcWnd, &rcLine))
- InvalidateRect16(wndPtr->hwndSelf, &rcUpdate, FALSE);
+ if (IntersectRect32(&rcUpdate, &rcWnd, &rcLine))
+ InvalidateRect32(wndPtr->hwndSelf, &rcUpdate, FALSE);
}
EDIT_GetLineRect(wndPtr, el, 0, ec, &rcLine);
- if (IntersectRect16(&rcUpdate, &rcWnd, &rcLine))
- InvalidateRect16( wndPtr->hwndSelf, &rcUpdate, FALSE );
+ if (IntersectRect32(&rcUpdate, &rcWnd, &rcLine))
+ InvalidateRect32( wndPtr->hwndSelf, &rcUpdate, FALSE );
}
}
@@ -963,11 +1253,11 @@
* Calculates, for a given Y-coordinate on the screen, the line.
*
*/
-static UINT EDIT_LineFromWndY(WND *wndPtr, INT y)
+static INT32 EDIT_LineFromWndY(WND *wndPtr, INT32 y)
{
- UINT fv = (UINT)EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0L);
- UINT lh = EDIT_GetLineHeight(wndPtr);
- UINT lc = (UINT)EDIT_EM_GetLineCount(wndPtr, 0, 0L);
+ INT32 fv = (INT32)EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0);
+ INT32 lh = EDIT_GetLineHeight(wndPtr);
+ INT32 lc = (INT32)EDIT_EM_GetLineCount(wndPtr, 0, 0);
return MAX(0, MIN(lc - 1, y / lh + fv));
}
@@ -980,9 +1270,11 @@
* Try to fit size + 1 bytes in the buffer. Constrain to limits.
*
*/
-static BOOL EDIT_MakeFit(WND *wndPtr, UINT size)
+static BOOL32 EDIT_MakeFit(WND *wndPtr, INT32 size)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
+ HLOCAL32 hNew32;
+ HLOCAL16 hNew16;
if (size <= es->BufSize)
return TRUE;
@@ -994,11 +1286,33 @@
dprintf_edit(stddeb, "edit: EDIT_MakeFit: trying to ReAlloc to %d+1\n", size);
- if (LOCAL_ReAlloc(wndPtr->hInstance, es->hBuf, size + 1, LMEM_MOVEABLE)) {
- es->BufSize = MIN(LOCAL_Size(wndPtr->hInstance, es->hBuf) - 1, es->BufLimit);
- return TRUE;
- } else
- return FALSE;
+ 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);
+ 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);
+ return FALSE;
+ }
+ dprintf_edit(stddeb, "edit: EDIT_MakeFit: We now have %d+1\n", es->BufSize);
+ return TRUE;
+ }
+ }
+ return FALSE;
}
@@ -1007,23 +1321,27 @@
* EDIT_MoveBackward
*
*/
-static void EDIT_MoveBackward(WND *wndPtr, BOOL extend)
+static void EDIT_MoveBackward(WND *wndPtr, BOOL32 extend)
{
- UINT s = LOWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT e = HIWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT l = (UINT)EDIT_EM_LineFromChar(wndPtr, e, 0L);
- UINT li = (UINT)EDIT_EM_LineIndex(wndPtr, l, 0L);
+ INT32 s;
+ INT32 e;
+ INT32 l;
+ INT32 li;
+ EDIT_GetSel(wndPtr, &s, &e);
+ l = (INT32)EDIT_EM_LineFromChar(wndPtr, e, 0);
+ li = (INT32)EDIT_EM_LineIndex(wndPtr, l, 0);
if (e - li == 0) {
if (l) {
- li = (UINT)EDIT_EM_LineIndex(wndPtr, l - 1, 0L);
- e = li + (UINT)EDIT_EM_LineLength(wndPtr, li, 0L);
+ li = (INT32)EDIT_EM_LineIndex(wndPtr, l - 1, 0);
+ e = li + (INT32)EDIT_EM_LineLength(wndPtr, li, 0);
}
} else
e--;
if (!extend)
s = e;
- EDIT_EM_SetSel(wndPtr, 0, MAKELPARAM(s, e));
+ EDIT_EM_SetSel(wndPtr, s, e);
+ EDIT_EM_ScrollCaret(wndPtr, 0, 0);
}
@@ -1032,24 +1350,29 @@
* EDIT_MoveDownward
*
*/
-static void EDIT_MoveDownward(WND *wndPtr, BOOL extend)
+static void EDIT_MoveDownward(WND *wndPtr, BOOL32 extend)
{
- UINT s = LOWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT e = HIWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT l = (UINT)EDIT_EM_LineFromChar(wndPtr, e, 0L);
- UINT lc = (UINT)EDIT_EM_GetLineCount(wndPtr, e, 0L);
- UINT li = (UINT)EDIT_EM_LineIndex(wndPtr, l, 0L);
- INT x;
+ INT32 s;
+ INT32 e;
+ INT32 l;
+ INT32 lc;
+ INT32 li;
+ INT32 x;
+ EDIT_GetSel(wndPtr, &s, &e);
+ l = (INT32)EDIT_EM_LineFromChar(wndPtr, e, 0);
+ lc = (INT32)EDIT_EM_GetLineCount(wndPtr, e, 0);
+ li = (INT32)EDIT_EM_LineIndex(wndPtr, l, 0);
if (l < lc - 1) {
x = EDIT_WndXFromCol(wndPtr, l, e - li);
l++;
- e = (UINT)EDIT_EM_LineIndex(wndPtr, l, 0L) +
+ e = (INT32)EDIT_EM_LineIndex(wndPtr, l, 0) +
EDIT_ColFromWndX(wndPtr, l, x);
}
if (!extend)
s = e;
- EDIT_EM_SetSel(wndPtr, 0, MAKELPARAM(s, e));
+ EDIT_EM_SetSel(wndPtr, s, e);
+ EDIT_EM_ScrollCaret(wndPtr, 0, 0);
}
@@ -1058,18 +1381,23 @@
* EDIT_MoveEnd
*
*/
-static void EDIT_MoveEnd(WND *wndPtr, BOOL extend)
+static void EDIT_MoveEnd(WND *wndPtr, BOOL32 extend)
{
- UINT s = LOWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT e = HIWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT l = (UINT)EDIT_EM_LineFromChar(wndPtr, e, 0L);
- UINT ll = (UINT)EDIT_EM_LineLength(wndPtr, e, 0L);
- UINT li = (UINT)EDIT_EM_LineIndex(wndPtr, l, 0L);
+ INT32 s;
+ INT32 e;
+ INT32 l;
+ INT32 ll;
+ INT32 li;
+ EDIT_GetSel(wndPtr, &s, &e);
+ l = (INT32)EDIT_EM_LineFromChar(wndPtr, e, 0);
+ ll = (INT32)EDIT_EM_LineLength(wndPtr, e, 0);
+ li = (INT32)EDIT_EM_LineIndex(wndPtr, l, 0);
e = li + ll;
if (!extend)
s = e;
- EDIT_EM_SetSel(wndPtr, 0, MAKELPARAM(s, e));
+ EDIT_EM_SetSel(wndPtr, s, e);
+ EDIT_EM_ScrollCaret(wndPtr, 0, 0);
}
@@ -1078,23 +1406,29 @@
* EDIT_MoveForward
*
*/
-static void EDIT_MoveForward(WND *wndPtr, BOOL extend)
+static void EDIT_MoveForward(WND *wndPtr, BOOL32 extend)
{
- UINT s = LOWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT e = HIWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT l = (UINT)EDIT_EM_LineFromChar(wndPtr, e, 0L);
- UINT lc = (UINT)EDIT_EM_GetLineCount(wndPtr, e, 0L);
- UINT ll = (UINT)EDIT_EM_LineLength(wndPtr, e, 0L);
- UINT li = (UINT)EDIT_EM_LineIndex(wndPtr, l, 0L);
+ INT32 s;
+ INT32 e;
+ INT32 l;
+ INT32 lc;
+ INT32 ll;
+ INT32 li;
+ EDIT_GetSel(wndPtr, &s, &e);
+ l = (INT32)EDIT_EM_LineFromChar(wndPtr, e, 0);
+ lc = (INT32)EDIT_EM_GetLineCount(wndPtr, e, 0);
+ ll = (INT32)EDIT_EM_LineLength(wndPtr, e, 0);
+ li = (INT32)EDIT_EM_LineIndex(wndPtr, l, 0);
if (e - li == ll) {
if (l != lc - 1)
- e = (UINT)EDIT_EM_LineIndex(wndPtr, l + 1, 0L);
+ e = (INT32)EDIT_EM_LineIndex(wndPtr, l + 1, 0);
} else
e++;
if (!extend)
s = e;
- EDIT_EM_SetSel(wndPtr, 0, MAKELPARAM(s, e));
+ EDIT_EM_SetSel(wndPtr, s, e);
+ EDIT_EM_ScrollCaret(wndPtr, 0, 0);
}
@@ -1105,17 +1439,21 @@
* Home key: move to beginning of line.
*
*/
-static void EDIT_MoveHome(WND *wndPtr, BOOL extend)
+static void EDIT_MoveHome(WND *wndPtr, BOOL32 extend)
{
- UINT s = LOWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT e = HIWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT l = (UINT)EDIT_EM_LineFromChar(wndPtr, e, 0L);
- UINT li = (UINT)EDIT_EM_LineIndex(wndPtr, l, 0L);
+ INT32 s;
+ INT32 e;
+ INT32 l;
+ INT32 li;
+ EDIT_GetSel(wndPtr, &s, &e);
+ l = (INT32)EDIT_EM_LineFromChar(wndPtr, e, 0);
+ li = (INT32)EDIT_EM_LineIndex(wndPtr, l, 0);
e = li;
if (!extend)
s = e;
- EDIT_EM_SetSel(wndPtr, 0, MAKELPARAM(s, e));
+ EDIT_EM_SetSel(wndPtr, s, e);
+ EDIT_EM_ScrollCaret(wndPtr, 0, 0);
}
@@ -1124,24 +1462,29 @@
* EDIT_MovePageDown
*
*/
-static void EDIT_MovePageDown(WND *wndPtr, BOOL extend)
+static void EDIT_MovePageDown(WND *wndPtr, BOOL32 extend)
{
- UINT s = LOWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT e = HIWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT l = (UINT)EDIT_EM_LineFromChar(wndPtr, e, 0L);
- UINT lc = (UINT)EDIT_EM_GetLineCount(wndPtr, e, 0L);
- UINT li = (UINT)EDIT_EM_LineIndex(wndPtr, l, 0L);
- INT x;
+ INT32 s;
+ INT32 e;
+ INT32 l;
+ INT32 lc;
+ INT32 li;
+ INT32 x;
+ EDIT_GetSel(wndPtr, &s, &e);
+ l = (INT32)EDIT_EM_LineFromChar(wndPtr, e, 0);
+ lc = (INT32)EDIT_EM_GetLineCount(wndPtr, e, 0);
+ li = (INT32)EDIT_EM_LineIndex(wndPtr, l, 0);
if (l < lc - 1) {
x = EDIT_WndXFromCol(wndPtr, l, e - li);
l = MIN(lc - 1, l + EDIT_GetVisibleLineCount(wndPtr));
- e = (UINT)EDIT_EM_LineIndex(wndPtr, l, 0L) +
+ e = (INT32)EDIT_EM_LineIndex(wndPtr, l, 0) +
EDIT_ColFromWndX(wndPtr, l, x);
}
if (!extend)
s = e;
- EDIT_EM_SetSel(wndPtr, 0, MAKELPARAM(s, e));
+ EDIT_EM_SetSel(wndPtr, s, e);
+ EDIT_EM_ScrollCaret(wndPtr, 0, 0);
}
@@ -1150,23 +1493,27 @@
* EDIT_MovePageUp
*
*/
-static void EDIT_MovePageUp(WND *wndPtr, BOOL extend)
+static void EDIT_MovePageUp(WND *wndPtr, BOOL32 extend)
{
- UINT s = LOWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT e = HIWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT l = (UINT)EDIT_EM_LineFromChar(wndPtr, e, 0L);
- UINT li = (UINT)EDIT_EM_LineIndex(wndPtr, l, 0L);
- INT x;
+ INT32 s;
+ INT32 e;
+ INT32 l;
+ INT32 li;
+ INT32 x;
+ EDIT_GetSel(wndPtr, &s, &e);
+ l = (INT32)EDIT_EM_LineFromChar(wndPtr, e, 0);
+ li = (INT32)EDIT_EM_LineIndex(wndPtr, l, 0);
if (l) {
x = EDIT_WndXFromCol(wndPtr, l, e - li);
l = MAX(0, l - EDIT_GetVisibleLineCount(wndPtr));
- e = (UINT)EDIT_EM_LineIndex(wndPtr, l, 0L) +
+ e = (INT32)EDIT_EM_LineIndex(wndPtr, l, 0) +
EDIT_ColFromWndX(wndPtr, l, x);
}
if (!extend)
s = e;
- EDIT_EM_SetSel(wndPtr, 0, MAKELPARAM(s, e));
+ EDIT_EM_SetSel(wndPtr, s, e);
+ EDIT_EM_ScrollCaret(wndPtr, 0, 0);
}
@@ -1175,23 +1522,27 @@
* EDIT_MoveUpward
*
*/
-static void EDIT_MoveUpward(WND *wndPtr, BOOL extend)
+static void EDIT_MoveUpward(WND *wndPtr, BOOL32 extend)
{
- UINT s = LOWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT e = HIWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT l = (UINT)EDIT_EM_LineFromChar(wndPtr, e, 0L);
- UINT li = (UINT)EDIT_EM_LineIndex(wndPtr, l, 0L);
- INT x;
+ INT32 s;
+ INT32 e;
+ INT32 l;
+ INT32 li;
+ INT32 x;
+ EDIT_GetSel(wndPtr, &s, &e);
+ l = (INT32)EDIT_EM_LineFromChar(wndPtr, e, 0);
+ li = (INT32)EDIT_EM_LineIndex(wndPtr, l, 0);
if (l) {
x = EDIT_WndXFromCol(wndPtr, l, e - li);
l--;
- e = (UINT)EDIT_EM_LineIndex(wndPtr, l, 0L) +
+ e = (INT32)EDIT_EM_LineIndex(wndPtr, l, 0) +
EDIT_ColFromWndX(wndPtr, l, x);
}
if (!extend)
s = e;
- EDIT_EM_SetSel(wndPtr, 0, MAKELPARAM(s, e));
+ EDIT_EM_SetSel(wndPtr, s, e);
+ EDIT_EM_ScrollCaret(wndPtr, 0, 0);
}
@@ -1200,28 +1551,33 @@
* EDIT_MoveWordBackward
*
*/
-static void EDIT_MoveWordBackward(WND *wndPtr, BOOL extend)
+static void EDIT_MoveWordBackward(WND *wndPtr, BOOL32 extend)
{
- UINT s = LOWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT e = HIWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT l = (UINT)EDIT_EM_LineFromChar(wndPtr, e, 0L);
- UINT ll = (UINT)EDIT_EM_LineLength(wndPtr, e, 0L);
- UINT li = (UINT)EDIT_EM_LineIndex(wndPtr, l, 0L);
- char *text;
+ INT32 s;
+ INT32 e;
+ INT32 l;
+ INT32 ll;
+ INT32 li;
+ LPSTR text;
+ EDIT_GetSel(wndPtr, &s, &e);
+ l = (INT32)EDIT_EM_LineFromChar(wndPtr, e, 0);
+ ll = (INT32)EDIT_EM_LineLength(wndPtr, e, 0);
+ li = (INT32)EDIT_EM_LineIndex(wndPtr, l, 0);
if (e - li == 0) {
if (l) {
- li = (UINT)EDIT_EM_LineIndex(wndPtr, l - 1, 0L);
- e = li + (UINT)EDIT_EM_LineLength(wndPtr, li, 0L);
+ li = (INT32)EDIT_EM_LineIndex(wndPtr, l - 1, 0);
+ e = li + (INT32)EDIT_EM_LineLength(wndPtr, li, 0);
}
} else {
text = EDIT_GetPointer(wndPtr);
- e = li + (UINT)EDIT_CallWordBreakProc(wndPtr,
+ e = li + (INT32)EDIT_CallWordBreakProc(wndPtr,
text + li, e - li, ll, WB_LEFT);
}
if (!extend)
s = e;
- EDIT_EM_SetSel(wndPtr, 0, MAKELPARAM(s, e));
+ EDIT_EM_SetSel(wndPtr, s, e);
+ EDIT_EM_ScrollCaret(wndPtr, 0, 0);
}
@@ -1230,27 +1586,33 @@
* EDIT_MoveWordForward
*
*/
-static void EDIT_MoveWordForward(WND *wndPtr, BOOL extend)
+static void EDIT_MoveWordForward(WND *wndPtr, BOOL32 extend)
{
- UINT s = LOWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT e = HIWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT l = (UINT)EDIT_EM_LineFromChar(wndPtr, e, 0L);
- UINT lc = (UINT)EDIT_EM_GetLineCount(wndPtr, e, 0L);
- UINT ll = (UINT)EDIT_EM_LineLength(wndPtr, e, 0L);
- UINT li = (UINT)EDIT_EM_LineIndex(wndPtr, l, 0L);
- char *text;
+ 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, 0);
+ lc = (INT32)EDIT_EM_GetLineCount(wndPtr, e, 0);
+ ll = (INT32)EDIT_EM_LineLength(wndPtr, e, 0);
+ li = (INT32)EDIT_EM_LineIndex(wndPtr, l, 0);
if (e - li == ll) {
if (l != lc - 1)
- e = (UINT)EDIT_EM_LineIndex(wndPtr, l + 1, 0L);
+ e = (INT32)EDIT_EM_LineIndex(wndPtr, l + 1, 0);
} else {
text = EDIT_GetPointer(wndPtr);
- e = li + (UINT)EDIT_CallWordBreakProc(wndPtr,
+ e = li + EDIT_CallWordBreakProc(wndPtr,
text + li, e - li + 1, ll, WB_RIGHT);
}
if (!extend)
s = e;
- EDIT_EM_SetSel(wndPtr, 0, MAKELPARAM(s, e));
+ EDIT_EM_SetSel(wndPtr, s, e);
+ EDIT_EM_ScrollCaret(wndPtr, 0, 0);
}
@@ -1259,17 +1621,17 @@
* EDIT_PaintLine
*
*/
-static void EDIT_PaintLine(WND *wndPtr, HDC32 hdc, UINT line, BOOL rev)
+static void EDIT_PaintLine(WND *wndPtr, HDC32 hdc, INT32 line, BOOL32 rev)
{
- UINT fv = (UINT)EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0L);
- UINT vlc = EDIT_GetVisibleLineCount(wndPtr);
- UINT lc = (UINT)EDIT_EM_GetLineCount(wndPtr, 0, 0L);
- UINT li;
- UINT ll;
- UINT s;
- UINT e;
- INT x;
- INT y;
+ INT32 fv = (INT32)EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0);
+ INT32 vlc = EDIT_GetVisibleLineCount(wndPtr);
+ INT32 lc = (INT32)EDIT_EM_GetLineCount(wndPtr, 0, 0);
+ INT32 li;
+ INT32 ll;
+ INT32 s;
+ INT32 e;
+ INT32 x;
+ INT32 y;
if ((line < fv) || (line > fv + vlc) || (line >= lc))
return;
@@ -1278,11 +1640,10 @@
x = EDIT_WndXFromCol(wndPtr, line, 0);
y = EDIT_WndYFromLine(wndPtr, line);
- li = (UINT)EDIT_EM_LineIndex(wndPtr, line, 0L);
- ll = (UINT)EDIT_EM_LineLength(wndPtr, li, 0L);
- s = LOWORD(EDIT_GetSel(wndPtr, 0, 0L));
- e = HIWORD(EDIT_GetSel(wndPtr, 0, 0L));
- ORDER_UINT(s, e);
+ li = (INT32)EDIT_EM_LineIndex(wndPtr, line, 0);
+ ll = (INT32)EDIT_EM_LineLength(wndPtr, li, 0);
+ 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) &&
@@ -1301,15 +1662,15 @@
* EDIT_PaintText
*
*/
-static UINT EDIT_PaintText(WND *wndPtr, HDC32 hdc, INT x, INT y, UINT line, UINT col, UINT count, BOOL rev)
+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;
- UINT ret;
- char *text;
- UINT li;
- UINT xoff;
+ INT32 ret;
+ LPSTR text;
+ INT32 li;
+ INT32 xoff;
if (!count)
return 0;
@@ -1320,9 +1681,9 @@
SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
}
text = EDIT_GetPasswordPointer(wndPtr);
- li = (UINT)EDIT_EM_LineIndex(wndPtr, line, 0L);
+ li = (INT32)EDIT_EM_LineIndex(wndPtr, line, 0);
xoff = EDIT_GetXOffset(wndPtr);
- ret = LOWORD(TabbedTextOut(hdc, x, y, text + li + col, count,
+ ret = (INT32)LOWORD(TabbedTextOut(hdc, x, y, text + li + col, count,
es->NumTabStops, es->TabStops, -xoff));
free(text);
if (rev) {
@@ -1330,7 +1691,7 @@
SetTextColor(hdc, TextColor);
}
return ret;
-}
+}
/*********************************************************************
@@ -1339,138 +1700,51 @@
*
* This is the only helper function that can be called with es = NULL.
* It is called at the end of EditWndProc() to unlock the buffer.
- *
+ *
*/
static void EDIT_ReleasePointer(WND *wndPtr)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
-
+
if (!es)
return;
- if (es->text && es->hBuf)
- LOCAL_Unlock(wndPtr->hInstance, es->hBuf);
+ if (es->text && (es->hBuf32 || es->hBuf16))
+ {
+ if (es->hBuf32)
+ LocalUnlock32(es->hBuf32);
+ else
+ LOCAL_Unlock(wndPtr->hInstance, es->hBuf16);
+ }
es->text = NULL;
}
/*********************************************************************
*
- * EDIT_ReplaceSel
- *
- * Beware: This is not the function called on EM_REPLACESEL.
- * It expects a (char *) in lParam, not a (SEGPTR).
- * It is used internally, as if there were no pointer difficulties.
- *
- */
-static LRESULT EDIT_ReplaceSel(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
-{
- const char *str = (char *)lParam;
- int strl = strlen(str);
- UINT tl = (UINT)EDIT_WM_GetTextLength(wndPtr, 0, 0L);
- UINT s = LOWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT e = HIWORD(EDIT_GetSel(wndPtr, 0, 0L));
- int i;
- char *p;
- char *text;
- BOOL redraw;
-
- ORDER_UINT(s,e);
- if (!EDIT_MakeFit(wndPtr, tl - (e - s) + strl)) {
- EDIT_NOTIFY_PARENT(wndPtr, EN_MAXTEXT);
- return 0L;
- }
- redraw = EDIT_GetRedraw(wndPtr);
- EDIT_WM_SetRedraw(wndPtr, FALSE, 0L);
- EDIT_WM_Clear(wndPtr, 0, 0L);
- tl = EDIT_WM_GetTextLength(wndPtr, 0, 0L);
- e = HIWORD(EDIT_GetSel(wndPtr, 0, 0L));
- text = EDIT_GetPointer(wndPtr);
- for (p = text + tl ; p >= text + e ; p--)
- p[strl] = p[0];
- for (i = 0 , p = text + e ; i < strl ; i++)
- p[i] = str[i];
- if(IsUpper(wndPtr))
- AnsiUpperBuff(p, strl);
- else if(IsLower(wndPtr))
- AnsiLowerBuff(p, strl);
- EDIT_BuildLineDefs(wndPtr);
- e += strl;
- EDIT_EM_SetSel(wndPtr, 0, MAKELPARAM(e, e));
- EDIT_EM_SetModify(wndPtr, TRUE, 0L);
- EDIT_NOTIFY_PARENT(wndPtr, EN_UPDATE);
- EDIT_WM_SetRedraw(wndPtr, redraw, 0L);
- if (redraw) {
- InvalidateRect32( wndPtr->hwndSelf, NULL, TRUE );
- EDIT_NOTIFY_PARENT(wndPtr, EN_CHANGE);
- }
- return 0L;
-}
-
-
-/*********************************************************************
- *
- * EDIT_ScrollIntoView
- *
- * Makes sure the caret is visible.
- *
- */
-static void EDIT_ScrollIntoView(WND *wndPtr)
-{
- UINT e = HIWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT l = (UINT)EDIT_EM_LineFromChar(wndPtr, e, 0L);
- UINT li = (UINT)EDIT_EM_LineIndex(wndPtr, l, 0L);
- UINT fv = (UINT)EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0L);
- UINT vlc = EDIT_GetVisibleLineCount(wndPtr);
- UINT ww = EDIT_GetWndWidth(wndPtr);
- UINT cw = EDIT_GetAveCharWidth(wndPtr);
- INT x = EDIT_WndXFromCol(wndPtr, l, e - li);
- int dy = 0;
- int dx = 0;
-
- 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, 0, MAKELPARAM(dy, dx));
- if (dy)
- EDIT_NOTIFY_PARENT(wndPtr, EN_VSCROLL);
- if (dx)
- EDIT_NOTIFY_PARENT(wndPtr, EN_HSCROLL);
- }
-}
-
-
-/*********************************************************************
- *
* EDIT_WndXFromCol
*
* Calculates, for a given line and column, the X-coordinate on the screen.
*
*/
-static INT EDIT_WndXFromCol(WND *wndPtr, UINT line, UINT col)
-{
+static INT32 EDIT_WndXFromCol(WND *wndPtr, INT32 line, INT32 col)
+{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
- char *text = EDIT_GetPasswordPointer(wndPtr);
- INT ret;
+ LPSTR text = EDIT_GetPasswordPointer(wndPtr);
+ INT32 ret;
HDC32 hdc;
- HFONT16 hFont;
+ HFONT32 hFont;
HFONT32 oldFont = 0;
- UINT lc = (UINT)EDIT_EM_GetLineCount(wndPtr, 0, 0L);
- UINT li = (UINT)EDIT_EM_LineIndex(wndPtr, line, 0L);
- UINT ll = (UINT)EDIT_EM_LineLength(wndPtr, li, 0L);
- UINT xoff = EDIT_GetXOffset(wndPtr);
+ INT32 lc = (INT32)EDIT_EM_GetLineCount(wndPtr, 0, 0);
+ INT32 li = (INT32)EDIT_EM_LineIndex(wndPtr, line, 0);
+ INT32 ll = (INT32)EDIT_EM_LineLength(wndPtr, li, 0);
+ INT32 xoff = EDIT_GetXOffset(wndPtr);
hdc = GetDC32(wndPtr->hwndSelf);
- hFont = (HFONT16)EDIT_WM_GetFont(wndPtr, 0, 0L);
+ hFont = (HFONT32)EDIT_WM_GetFont(wndPtr, 0, 0);
if (hFont) oldFont = SelectObject32(hdc, hFont);
line = MAX(0, MIN(line, lc - 1));
col = MIN(col, ll);
- ret = LOWORD(GetTabbedTextExtent(hdc,
+ ret = (INT32)LOWORD(GetTabbedTextExtent(hdc,
text + li, col,
es->NumTabStops, es->TabStops)) - xoff;
if (hFont) SelectObject32(hdc, oldFont);
@@ -1487,10 +1761,10 @@
* Calculates, for a given line, the Y-coordinate on the screen.
*
*/
-static INT EDIT_WndYFromLine(WND *wndPtr, UINT line)
+static INT32 EDIT_WndYFromLine(WND *wndPtr, INT32 line)
{
- UINT fv = (UINT)EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0L);
- UINT lh = EDIT_GetLineHeight(wndPtr);
+ INT32 fv = (INT32)EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0);
+ INT32 lh = EDIT_GetLineHeight(wndPtr);
return (line - fv) * lh;
}
@@ -1507,16 +1781,16 @@
* internally, so we can decide this for ourselves.
*
*/
-static INT EDIT_WordBreakProc(char *s, INT index, INT count, INT action)
+static INT32 EDIT_WordBreakProc(LPSTR s, INT32 index, INT32 count, INT32 action)
{
- INT ret = 0;
+ INT32 ret = 0;
- dprintf_edit(stddeb, "edit: EDIT_WordBreakProc: s=%p, index=%d"
- ", count=%d, action=%d\n", s, index, count, action);
+ 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)
+ if (!count)
break;
if (index)
index--;
@@ -1569,7 +1843,38 @@
*/
static LRESULT EDIT_EM_CanUndo(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- return 0L;
+ EDITSTATE *es = EDITSTATEPTR(wndPtr);
+
+ return (LRESULT)es->CanUndo;
+}
+
+
+/*********************************************************************
+ *
+ * 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, 0);
+ c = EDIT_ColFromWndX(wndPtr, l, pt.x);
+
+ return (LRESULT)MAKELONG(li + c, li);
}
@@ -1580,7 +1885,10 @@
*/
static LRESULT EDIT_EM_EmptyUndoBuffer(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- return 0L;
+ EDITSTATE *es = EDITSTATEPTR(wndPtr);
+
+ es->CanUndo = FALSE;
+ return 0;
}
@@ -1591,8 +1899,8 @@
*/
static LRESULT EDIT_EM_FmtLines(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- fprintf(stdnimp, "edit: EM_FMTLINES: message not implemented.\n");
- return wParam ? -1L : 0L;
+ fprintf(stdnimp, "edit: EM_FMTLINES: message not implemented\n");
+ return wParam ? TRUE : FALSE;
}
@@ -1604,8 +1912,11 @@
static LRESULT EDIT_EM_GetFirstVisibleLine(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
-
- return (LRESULT)es->FirstVisibleLine;
+
+ if (IsMultiLine(wndPtr))
+ return (LRESULT)es->FirstVisibleLine;
+ else
+ return (LRESULT)EDIT_ColFromWndX(wndPtr, 0, 0);
}
@@ -1618,9 +1929,91 @@
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
- return (LRESULT)es->hBuf;
+ 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, WPARAM32 wParam, LPARAM lParam)
+{
+ 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,
+ EDIT_WM_GetTextLength(wndPtr, 0, 0) + 1,
+ LMEM_MOVEABLE))) {
+ 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;
+}
+
/*********************************************************************
*
@@ -1629,21 +2022,21 @@
*/
static LRESULT EDIT_EM_GetLine(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- char *text;
- char *src;
- char *dst;
- UINT len;
- UINT i;
- UINT lc = (UINT)EDIT_EM_GetLineCount(wndPtr, 0, 0L);
+ LPSTR text;
+ LPSTR src;
+ LPSTR dst;
+ INT32 len;
+ INT32 i;
+ INT32 lc = (INT32)EDIT_EM_GetLineCount(wndPtr, 0, 0);
if (!IsMultiLine(wndPtr))
wParam = 0;
- if ((UINT)wParam >= lc)
- return 0L;
+ if ((INT32)wParam >= lc)
+ return 0;
text = EDIT_GetPointer(wndPtr);
- src = text + (UINT)EDIT_EM_LineIndex(wndPtr, wParam, 0L);
- dst = (char *)PTR_SEG_TO_LIN(lParam);
- len = MIN(*(WORD *)dst, (UINT)EDIT_EM_LineLength(wndPtr, wParam, 0L));
+ src = text + (INT32)EDIT_EM_LineIndex(wndPtr, wParam, 0);
+ dst = (LPSTR)lParam;
+ len = MIN(*(WORD *)dst, (INT32)EDIT_EM_LineLength(wndPtr, wParam, 0));
for (i = 0 ; i < len ; i++) {
*dst = *src;
src++;
@@ -1661,13 +2054,26 @@
static LRESULT EDIT_EM_GetLineCount(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
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
*
*/
@@ -1699,7 +2105,24 @@
*/
static LRESULT EDIT_EM_GetRect(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- return EDIT_GetRect(wndPtr, wParam, (LPARAM)PTR_SEG_TO_LIN(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;
}
@@ -1713,11 +2136,16 @@
*/
static LRESULT EDIT_EM_GetSel(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- UINT s = LOWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT e = HIWORD(EDIT_GetSel(wndPtr, 0, 0L));
+ INT32 s;
+ INT32 e;
- ORDER_UINT(s, e);
- return MAKELONG(s, 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);
}
@@ -1725,13 +2153,16 @@
*
* EM_GETTHUMB
*
- * FIXME: undocumented: is this right ?
+ * 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, WPARAM32 wParam, LPARAM lParam)
{
- return MAKELONG(EDIT_WM_VScroll(wndPtr, EM_GETTHUMB, 0L),
- EDIT_WM_HScroll(wndPtr, EM_GETTHUMB, 0L));
+ return MAKELONG(EDIT_WM_VScroll(wndPtr, EM_GETTHUMB16, 0),
+ EDIT_WM_HScroll(wndPtr, EM_GETTHUMB16, 0));
}
@@ -1739,36 +2170,17 @@
*
* 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;
-}
-
-
-/*********************************************************************
- *
- * EM_LIMITTEXT
- *
- */
-static LRESULT EDIT_EM_LimitText(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
-{
- EDITSTATE *es = EDITSTATEPTR(wndPtr);
-
- if (IsMultiLine(wndPtr)) {
- if (wParam)
- es->BufLimit = MIN((UINT)wParam, BUFLIMIT_MULTI);
- else
- es->BufLimit = BUFLIMIT_MULTI;
- } else {
- if (wParam)
- es->BufLimit = MIN((UINT)wParam, BUFLIMIT_SINGLE);
- else
- es->BufLimit = BUFLIMIT_SINGLE;
- }
- return 0L;
+*/
+ return 0;
}
@@ -1779,14 +2191,14 @@
*/
static LRESULT EDIT_EM_LineFromChar(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- UINT l;
+ INT32 l;
if (!IsMultiLine(wndPtr))
- return 0L;
- if ((INT)wParam == -1)
- wParam = HIWORD(EDIT_GetSel(wndPtr, 0, 0L));
- l = (UINT)EDIT_EM_GetLineCount(wndPtr, 0, 0L) - 1;
- while ((UINT)EDIT_EM_LineIndex(wndPtr, l, 0L) > (UINT)wParam)
+ 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, 0, 0) - 1;
+ while ((INT32)EDIT_EM_LineIndex(wndPtr, l, 0) > (INT32)wParam)
l--;
return (LRESULT)l;
}
@@ -1800,20 +2212,20 @@
static LRESULT EDIT_EM_LineIndex(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
- UINT e;
- UINT l;
- UINT lc = (UINT)EDIT_EM_GetLineCount(wndPtr, 0, 0L);
+ INT32 e;
+ INT32 l;
+ INT32 lc = (INT32)EDIT_EM_GetLineCount(wndPtr, 0, 0);
- if ((INT)wParam == -1) {
- e = HIWORD(EDIT_GetSel(wndPtr, 0, 0L));
+ 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 ((UINT)wParam >= lc)
- return -1L;
- return (LRESULT)es->LineDefs[(UINT)wParam].offset;
+ if ((INT32)wParam >= lc)
+ return -1;
+ return (LRESULT)es->LineDefs[(INT32)wParam].offset;
}
@@ -1825,43 +2237,47 @@
static LRESULT EDIT_EM_LineLength(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
- UINT s;
- UINT e;
- UINT sl;
- UINT el;
+ INT32 s;
+ INT32 e;
+ INT32 sl;
+ INT32 el;
if (!IsMultiLine(wndPtr))
return (LRESULT)es->LineDefs[0].length;
- if ((INT)wParam == -1) {
- s = LOWORD(EDIT_GetSel(wndPtr, 0, 0L));
- e = HIWORD(EDIT_GetSel(wndPtr, 0, 0L));
- sl = (UINT)EDIT_EM_LineFromChar(wndPtr, s, 0L);
- el = (UINT)EDIT_EM_LineFromChar(wndPtr, e, 0L);
+ if ((INT32)wParam == -1) {
+ EDIT_GetSel(wndPtr, &s, &e);
+ sl = (INT32)EDIT_EM_LineFromChar(wndPtr, s, 0);
+ el = (INT32)EDIT_EM_LineFromChar(wndPtr, e, 0);
return (LRESULT)(s - es->LineDefs[sl].offset +
es->LineDefs[el].offset +
es->LineDefs[el].length - e);
}
- return (LRESULT)es->LineDefs[(UINT)EDIT_EM_LineFromChar(wndPtr, wParam, 0L)].length;
+ return (LRESULT)es->LineDefs[(INT32)EDIT_EM_LineFromChar(wndPtr, wParam, 0)].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);
- UINT lc = (UINT)EDIT_EM_GetLineCount(wndPtr, 0, 0L);
- UINT fv = (UINT)EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0L);
- UINT nfv = MAX(0, fv + (INT)LOWORD(lParam));
- UINT xoff = EDIT_GetXOffset(wndPtr);
- UINT nxoff = MAX(0, xoff + (INT)HIWORD(lParam));
- UINT tw = EDIT_GetTextWidth(wndPtr);
- INT dx;
- INT dy;
- POINT16 pos;
+ INT32 lc = (INT32)EDIT_EM_GetLineCount(wndPtr, 0, 0);
+ INT32 fv = (INT32)EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0);
+ 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;
+ POINT32 pos;
if (nfv >= lc)
nfv = lc - 1;
@@ -1873,23 +2289,45 @@
if (dx || dy) {
if (wndPtr->hwndSelf == GetFocus32())
HideCaret(wndPtr->hwndSelf);
- if (EDIT_GetRedraw(wndPtr))
+ if (EDIT_GetRedraw(wndPtr))
ScrollWindow32(wndPtr->hwndSelf, dx, dy, NULL, NULL);
es->FirstVisibleLine = nfv;
es->XOffset = nxoff;
if (IsVScrollBar(wndPtr))
SetScrollPos32(wndPtr->hwndSelf, SB_VERT,
- EDIT_WM_VScroll(wndPtr, EM_GETTHUMB, 0L), TRUE);
+ EDIT_WM_VScroll(wndPtr, EM_GETTHUMB16, 0), TRUE);
if (IsHScrollBar(wndPtr))
SetScrollPos32(wndPtr->hwndSelf, SB_HORZ,
- EDIT_WM_HScroll(wndPtr, EM_GETTHUMB, 0L), TRUE);
+ EDIT_WM_HScroll(wndPtr, EM_GETTHUMB16, 0), TRUE);
if (wndPtr->hwndSelf == GetFocus32()) {
- GetCaretPos16(&pos);
+ GetCaretPos32(&pos);
SetCaretPos(pos.x + dx, pos.y + dy);
ShowCaret(wndPtr->hwndSelf);
}
}
- return -1L;
+ if (IsMultiLine(wndPtr))
+ return TRUE;
+ else
+ return FALSE;
+}
+
+
+/*********************************************************************
+ *
+ * EM_POSFROMCHAR
+ *
+ */
+static LRESULT EDIT_EM_PosFromChar(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+{
+ INT32 len = (INT32)EDIT_WM_GetTextLength(wndPtr, 0, 0);
+ INT32 l;
+ INT32 li;
+
+ wParam = MIN(wParam, len);
+ l = EDIT_EM_LineFromChar(wndPtr, wParam, 0);
+ li = EDIT_EM_LineIndex(wndPtr, l, 0);
+ return (LRESULT)MAKELONG(EDIT_WndXFromCol(wndPtr, l, wParam - li),
+ EDIT_WndYFromLine(wndPtr, l));
}
@@ -1897,25 +2335,120 @@
*
* EM_REPLACESEL
*
+ * FIXME: wParam indicates whether we should maintain an undo buffer
+ * for this operation.
+ *
*/
static LRESULT EDIT_EM_ReplaceSel(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- return (LRESULT)EDIT_ReplaceSel(wndPtr, wParam,
- (LPARAM)(char *)PTR_SEG_TO_LIN(lParam));
+ LPCSTR str = (LPCSTR)lParam;
+ INT32 strl = lstrlen32A(str);
+ INT32 tl = (INT32)EDIT_WM_GetTextLength(wndPtr, 0, 0);
+ INT32 s;
+ INT32 e;
+ INT32 i;
+ LPSTR p;
+ LPSTR text;
+ BOOL32 redraw;
+
+ EDIT_GetSel(wndPtr, &s, &e);
+ ORDER_INT32(s,e);
+ if (!EDIT_MakeFit(wndPtr, tl - (e - s) + strl)) {
+ dprintf_edit(stddeb, "edit: notification EN_MAXTEXT sent\n");
+ EDIT_NOTIFY_PARENT(wndPtr, EN_MAXTEXT);
+ return 0;
+ }
+ redraw = EDIT_GetRedraw(wndPtr);
+ EDIT_WM_SetRedraw(wndPtr, FALSE, 0);
+ EDIT_WM_Clear(wndPtr, 0, 0);
+ tl = EDIT_WM_GetTextLength(wndPtr, 0, 0);
+ EDIT_GetSel(wndPtr, NULL, &e);
+ text = EDIT_GetPointer(wndPtr);
+ for (p = text + tl ; p >= text + e ; p--)
+ p[strl] = p[0];
+ for (i = 0 , p = text + e ; i < strl ; i++)
+ p[i] = str[i];
+ if(IsUpper(wndPtr))
+ CharUpperBuff32A(p, strl);
+ else if(IsLower(wndPtr))
+ CharLowerBuff32A(p, strl);
+ EDIT_BuildLineDefs(wndPtr);
+ e += strl;
+ EDIT_EM_SetSel(wndPtr, e, e);
+ EDIT_EM_ScrollCaret(wndPtr, 0, 0);
+ EDIT_EM_SetModify(wndPtr, TRUE, 0);
+ dprintf_edit(stddeb, "edit: notification EN_UPDATE sent\n");
+ EDIT_NOTIFY_PARENT(wndPtr, EN_UPDATE);
+ EDIT_WM_SetRedraw(wndPtr, redraw, 0);
+ 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
*
- * FIXME: undocumented message.
+ * FIXME: Scroll what ??? And where ???
*
*/
static LRESULT EDIT_EM_Scroll(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- fprintf(stdnimp, "edit: EM_SCROLL: message not implemented (undocumented), please report.\n");
- return 0L;
+ fprintf(stdnimp, "edit: EM_SCROLL: message not implemented\n");
+ return 0;
+}
+
+
+/*********************************************************************
+ *
+ * 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, WPARAM32 wParam, LPARAM lParam)
+{
+ INT32 e;
+ INT32 l;
+ INT32 li;
+ INT32 fv = (INT32)EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0);
+ 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, 0);
+ li = (INT32)EDIT_EM_LineIndex(wndPtr, l, 0);
+ 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;
}
@@ -1933,19 +2466,105 @@
/*
* old buffer is freed by caller
*/
- es->hBuf = (HLOCAL16)wParam;
- es->BufSize = LOCAL_Size(wndPtr->hInstance, es->hBuf) - 1;
+ 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, 0, 0L);
- EDIT_EM_SetModify(wndPtr, FALSE, 0L);
+ EDIT_EM_EmptyUndoBuffer(wndPtr, 0, 0);
+ EDIT_EM_SetModify(wndPtr, FALSE, 0);
EDIT_BuildLineDefs(wndPtr);
if (EDIT_GetRedraw(wndPtr))
InvalidateRect32( wndPtr->hwndSelf, NULL, TRUE );
- EDIT_ScrollIntoView(wndPtr);
+ EDIT_EM_ScrollCaret(wndPtr, 0, 0);
}
- return 0L;
+ return 0;
+}
+
+
+/*********************************************************************
+ *
+ * EM_SETHANDLE16
+ *
+ */
+static LRESULT EDIT_EM_SetHandle16(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+{
+ 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, 0, 0);
+ EDIT_EM_SetModify(wndPtr, FALSE, 0);
+ EDIT_BuildLineDefs(wndPtr);
+ if (EDIT_GetRedraw(wndPtr))
+ InvalidateRect32( wndPtr->hwndSelf, NULL, TRUE );
+ EDIT_EM_ScrollCaret(wndPtr, 0, 0);
+ }
+ return 0;
+}
+
+
+/*********************************************************************
+ *
+ * EM_SETLIMITTEXT
+ *
+ */
+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;
}
@@ -1958,8 +2577,8 @@
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
- es->TextChanged = (BOOL)wParam;
- return 0L;
+ es->TextChanged = (BOOL32)wParam;
+ return 0;
}
@@ -1967,13 +2586,15 @@
*
* EM_SETPASSWORDCHAR
*
+ * FIXME: This imlementation is way too simple
+ *
*/
static LRESULT EDIT_EM_SetPasswordChar(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
- es->PasswordChar = (char)wParam;
- return 0L;
+ es->PasswordChar = (CHAR)wParam;
+ return 0;
}
@@ -1984,11 +2605,11 @@
*/
static LRESULT EDIT_EM_SetReadOnly(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- if ((BOOL)wParam)
+ if ((BOOL32)wParam)
wndPtr->dwStyle |= ES_READONLY;
else
wndPtr->dwStyle &= ~(DWORD)ES_READONLY;
- return 0L;
+ return TRUE;
}
@@ -1999,8 +2620,8 @@
*/
static LRESULT EDIT_EM_SetRect(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- fprintf(stdnimp,"edit: EM_SETRECT: message not implemented, please report.\n");
- return 0L;
+ fprintf(stdnimp,"edit: EM_SETRECT: message not implemented\n");
+ return 0;
}
@@ -2011,8 +2632,8 @@
*/
static LRESULT EDIT_EM_SetRectNP(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- fprintf(stdnimp,"edit: EM_SETRECTNP: message not implemented, please report.\n");
- return 0L;
+ fprintf(stdnimp,"edit: EM_SETRECTNP: message not implemented\n");
+ return 0;
}
@@ -2020,50 +2641,76 @@
*
* EM_SETSEL
*
+ * FIXME: specs state that we should order start and end.
+ * However, we use internally that this is not the case.
+ *
*/
static LRESULT EDIT_EM_SetSel(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
- UINT ns = LOWORD(lParam);
- UINT ne = HIWORD(lParam);
- UINT s = LOWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT e = HIWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT el;
- UINT eli;
- UINT tl = (UINT)EDIT_WM_GetTextLength(wndPtr, 0, 0L);
+ INT32 ns = (INT32)wParam;
+ INT32 ne = (INT32)lParam;
+ INT32 s;
+ INT32 e;
+ INT32 el;
+ INT32 eli;
+ INT32 tl = (INT32)EDIT_WM_GetTextLength(wndPtr, 0, 0);
- if ((INT)ns == -1) {
+ EDIT_GetSel(wndPtr, &s, &e);
+ if (ns == -1) {
ns = e;
ne = e;
}
- else {
- ns = MIN(ns, tl);
- ne = MIN(ne, tl);
- }
+ if (ne == -1)
+ ne = e;
+/*
+ ORDER_INT32(ns, ne);
+*/
+ ns = MIN(ns, tl);
+ ne = MIN(ne, tl);
es->SelStart = ns;
es->SelEnd = ne;
if (wndPtr->hwndSelf == GetFocus32()) {
- el = (UINT)EDIT_EM_LineFromChar(wndPtr, ne, 0L);
- eli = (UINT)EDIT_EM_LineIndex(wndPtr, el, 0L);
+ el = (INT32)EDIT_EM_LineFromChar(wndPtr, ne, 0);
+ eli = (INT32)EDIT_EM_LineIndex(wndPtr, el, 0);
SetCaretPos(EDIT_WndXFromCol(wndPtr, el, ne - eli),
EDIT_WndYFromLine(wndPtr, el));
}
- if (!wParam)
- EDIT_ScrollIntoView(wndPtr);
if (EDIT_GetRedraw(wndPtr)) {
- ORDER_UINT(s, e);
- ORDER_UINT(s, ns);
- ORDER_UINT(s, ne);
- ORDER_UINT(e, ns);
- ORDER_UINT(e, ne);
- ORDER_UINT(ns, ne);
+ ORDER_INT32(s, e);
+ 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);
}
- return -1L;
+ 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 ((INT16)HIWORD(lParam) == -1)
+ ne = -1;
+ EDIT_EM_SetSel(wndPtr, ns, ne);
+ if (!wParam)
+ EDIT_EM_ScrollCaret(wndPtr, 0, 0);
+ return -1;
}
@@ -2075,20 +2722,46 @@
static LRESULT EDIT_EM_SetTabStops(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
+ INT32 i;
if (!IsMultiLine(wndPtr))
- return 0L;
+ return FALSE;
if (es->TabStops)
free(es->TabStops);
- es->NumTabStops = (UINT)wParam;
+ es->NumTabStops = (INT32)wParam;
+ if (!wParam)
+ es->TabStops = NULL;
+ else {
+ es->TabStops = (LPINT16)xmalloc(wParam * sizeof(INT16));
+ for ( i = 0 ; i < (INT32)wParam ; i++ )
+ es->TabStops[i] = (INT16)((LPINT32)lParam)[i];
+ }
+ return TRUE;
+}
+
+
+/*********************************************************************
+ *
+ * EM_SETTABSTOPS16
+ *
+ */
+static LRESULT EDIT_EM_SetTabStops16(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 = (LPINT16)xmalloc(wParam * sizeof(INT16));
memcpy(es->TabStops, (LPINT16)PTR_SEG_TO_LIN(lParam),
- (UINT)wParam * sizeof(INT16));
+ (INT32)wParam * sizeof(INT16));
}
- return 1L;
+ return TRUE;
}
@@ -2099,10 +2772,12 @@
*/
static LRESULT EDIT_EM_SetWordBreakProc(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
+/*
EDITSTATE *es = EDITSTATEPTR(wndPtr);
es->WordBreakProc = (EDITWORDBREAKPROC)lParam;
- return 0L;
+*/
+ return 0;
}
@@ -2113,7 +2788,11 @@
*/
static LRESULT EDIT_EM_Undo(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- return 0L;
+ fprintf(stdnimp,"edit: EM_UNDO: message not implemented\n");
+ if (IsMultiLine(wndPtr))
+ return FALSE;
+ else
+ return TRUE;
}
@@ -2135,22 +2814,22 @@
EDIT_MoveHome(wndPtr, FALSE);
EDIT_MoveDownward(wndPtr, FALSE);
} else
- EDIT_ReplaceSel(wndPtr, 0, (LPARAM)"\r\n");
+ EDIT_EM_ReplaceSel(wndPtr, 0, (LPARAM)"\r\n");
}
break;
case '\t':
if (IsMultiLine(wndPtr) && !IsReadOnly(wndPtr))
- EDIT_ReplaceSel(wndPtr, 0, (LPARAM)"\t");
+ EDIT_EM_ReplaceSel(wndPtr, 0, (LPARAM)"\t");
break;
default:
if (!IsReadOnly(wndPtr) && (c >= ' ') && (c != 127)) {
str[0] = c;
str[1] = '\0';
- EDIT_ReplaceSel(wndPtr, 0, (LPARAM)str);
+ EDIT_EM_ReplaceSel(wndPtr, 0, (LPARAM)str);
}
break;
}
- return 0L;
+ return 0;
}
@@ -2161,28 +2840,32 @@
*/
static LRESULT EDIT_WM_Clear(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- UINT s = LOWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT e = HIWORD(EDIT_GetSel(wndPtr, 0, 0L));
- char *text;
- BOOL redraw;
-
+ INT32 s;
+ INT32 e;
+ LPSTR text;
+ BOOL32 redraw;
+
+ EDIT_GetSel(wndPtr, &s, &e);
if (s != e) {
redraw = EDIT_GetRedraw(wndPtr);
- EDIT_WM_SetRedraw(wndPtr, FALSE, 0L);
- ORDER_UINT(s, e);
+ EDIT_WM_SetRedraw(wndPtr, FALSE, 0);
+ ORDER_INT32(s, e);
text = EDIT_GetPointer(wndPtr);
- strcpy(text + s, text + e);
+ lstrcpy32A(text + s, text + e);
EDIT_BuildLineDefs(wndPtr);
- EDIT_EM_SetSel(wndPtr, 0, MAKELPARAM(s, s));
- EDIT_EM_SetModify(wndPtr, TRUE, 0L);
+ EDIT_EM_SetSel(wndPtr, s, s);
+ EDIT_EM_ScrollCaret(wndPtr, 0, 0);
+ EDIT_EM_SetModify(wndPtr, TRUE, 0);
+ dprintf_edit(stddeb, "edit: notification EN_UPDATE sent\n");
EDIT_NOTIFY_PARENT(wndPtr, EN_UPDATE);
- EDIT_WM_SetRedraw(wndPtr, redraw, 0L);
+ EDIT_WM_SetRedraw(wndPtr, redraw, 0);
if (redraw) {
InvalidateRect32( wndPtr->hwndSelf, NULL, TRUE );
+ dprintf_edit(stddeb, "edit: notification EN_CHANGE sent\n");
EDIT_NOTIFY_PARENT(wndPtr, EN_CHANGE);
}
}
- return -1L;
+ return -1;
}
@@ -2193,17 +2876,18 @@
*/
static LRESULT EDIT_WM_Copy(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- UINT s = LOWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT e = HIWORD(EDIT_GetSel(wndPtr, 0, 0L));
+ INT32 s;
+ INT32 e;
HGLOBAL16 hdst;
- char *text;
- char *dst;
- char *src;
- int i;
+ LPSTR text;
+ LPSTR dst;
+ LPSTR src;
+ INT32 i;
+ EDIT_GetSel(wndPtr, &s, &e);
if (e == s)
- return -1L;
- ORDER_UINT(s, e);
+ return -1;
+ ORDER_INT32(s, e);
hdst = GlobalAlloc16(GMEM_MOVEABLE, (DWORD)(e - s + 1));
dst = GlobalLock16(hdst);
text = EDIT_GetPointer(wndPtr);
@@ -2216,7 +2900,7 @@
EmptyClipboard();
SetClipboardData(CF_TEXT, hdst);
CloseClipboard();
- return -1L;
+ return -1;
}
@@ -2227,9 +2911,9 @@
*/
static LRESULT EDIT_WM_Create(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- CREATESTRUCT16 *cs = (CREATESTRUCT16 *)PTR_SEG_TO_LIN(lParam);
+ CREATESTRUCT32A *cs = (CREATESTRUCT32A *)lParam;
EDITSTATE *es;
- char *text;
+ LPSTR text;
es = xmalloc(sizeof(EDITSTATE));
memset(es, 0, sizeof(EDITSTATE));
@@ -2254,27 +2938,19 @@
es->BufLimit = BUFLIMIT_SINGLE;
es->PasswordChar = (cs->style & ES_PASSWORD) ? '*' : '\0';
}
- if (!LOCAL_HeapSize(wndPtr->hInstance)) {
- if (!LocalInit(wndPtr->hInstance, 0,
- GlobalSize16(wndPtr->hInstance))) {
- fprintf(stderr, "edit: WM_CREATE: could not initialize local heap\n");
- return -1L;
- }
- dprintf_edit(stddeb, "edit: WM_CREATE: local heap initialized\n");
- }
- if (!(es->hBuf = LOCAL_Alloc(wndPtr->hInstance, LMEM_MOVEABLE, es->BufSize + 1))) {
+ if (!(es->hBuf32 = LocalAlloc32(LMEM_MOVEABLE, es->BufSize + 1))) {
fprintf(stderr, "edit: WM_CREATE: unable to allocate buffer\n");
- return -1L;
+ return -1;
}
- es->BufSize = LOCAL_Size(wndPtr->hInstance, es->hBuf) - 1;
+ es->BufSize = LocalSize32(es->hBuf32) - 1;
text = EDIT_GetPointer(wndPtr);
*text = '\0';
EDIT_BuildLineDefs(wndPtr);
- EDIT_WM_SetFont(wndPtr, 0, 0L);
- if (cs->lpszName && *(char *)PTR_SEG_TO_LIN(cs->lpszName) != '\0')
+ EDIT_WM_SetFont(wndPtr, 0, 0);
+ if (cs->lpszName && *(cs->lpszName) != '\0')
EDIT_EM_ReplaceSel(wndPtr, FALSE, (LPARAM)cs->lpszName);
- EDIT_WM_SetRedraw(wndPtr, TRUE, 0L);
- return 0L;
+ EDIT_WM_SetRedraw(wndPtr, TRUE, 0);
+ return 0;
}
@@ -2285,9 +2961,9 @@
*/
static LRESULT EDIT_WM_Cut(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- EDIT_WM_Copy(wndPtr, 0, 0L);
- EDIT_WM_Clear(wndPtr, 0, 0L);
- return -1L;
+ EDIT_WM_Copy(wndPtr, 0, 0);
+ EDIT_WM_Clear(wndPtr, 0, 0);
+ return -1;
}
@@ -2304,10 +2980,13 @@
if (es->TabStops)
free(es->TabStops);
EDIT_ReleasePointer(wndPtr);
- LOCAL_Free(wndPtr->hInstance, es->hBuf);
+ if (es->hBuf32)
+ LocalFree32(es->hBuf32);
+ else
+ LOCAL_Free(wndPtr->hInstance, es->hBuf16);
free(es);
*(EDITSTATE **)&wndPtr->wExtra = NULL;
- return 0L;
+ return 0;
}
@@ -2319,7 +2998,7 @@
static LRESULT EDIT_WM_Enable(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
EDIT_InvalidateText(wndPtr, 0, -1);
- return 0L;
+ return 0;
}
@@ -2331,23 +3010,23 @@
static LRESULT EDIT_WM_EraseBkGnd(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
HBRUSH32 hBrush;
- RECT16 rc;
+ RECT32 rc;
- hBrush = (HBRUSH16)EDIT_SEND_CTLCOLOR(wndPtr, wParam);
+ hBrush = (HBRUSH32)EDIT_SEND_CTLCOLOR(wndPtr, wParam);
if (!hBrush) hBrush = (HBRUSH32)GetStockObject32(WHITE_BRUSH);
- GetClientRect16(wndPtr->hwndSelf, &rc);
- IntersectClipRect16( (HDC16)wParam, rc.left, rc.top,
- rc.right, rc.bottom);
- GetClipBox16((HDC16)wParam, &rc);
+ 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.
*/
- FillRect16((HDC16)wParam, &rc, hBrush);
- return -1L;
+ FillRect32((HDC32)wParam, &rc, hBrush);
+ return -1;
}
@@ -2382,14 +3061,14 @@
*/
static LRESULT EDIT_WM_GetText(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- char *text = EDIT_GetPointer(wndPtr);
- int len;
- LRESULT lResult = 0L;
+ LPSTR text = EDIT_GetPointer(wndPtr);
+ INT32 len;
+ LRESULT lResult = 0;
- len = strlen(text);
- if ((UINT)wParam > len) {
- strcpy((char *)PTR_SEG_TO_LIN(lParam), text);
- lResult = (LRESULT)len ;
+ len = lstrlen32A(text);
+ if ((INT32)wParam > len) {
+ lstrcpy32A((LPSTR)lParam, text);
+ lResult = (LRESULT)len + 1;
}
return lResult;
}
@@ -2402,11 +3081,11 @@
*/
static LRESULT EDIT_WM_GetTextLength(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- char *text = EDIT_GetPointer(wndPtr);
+ LPSTR text = EDIT_GetPointer(wndPtr);
- return (LRESULT)strlen(text);
+ return (LRESULT)lstrlen32A(text);
}
-
+
/*********************************************************************
*
@@ -2417,13 +3096,13 @@
*/
static LRESULT EDIT_WM_HScroll(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- UINT ww = EDIT_GetWndWidth(wndPtr);
- UINT tw = EDIT_GetTextWidth(wndPtr);
- UINT cw = EDIT_GetAveCharWidth(wndPtr);
- UINT xoff = EDIT_GetXOffset(wndPtr);
- INT dx = 0;
- BOOL not = TRUE;
- LRESULT ret = 0L;
+ 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:
@@ -2449,23 +3128,25 @@
* not = FALSE;
*/
case SB_THUMBPOSITION:
- dx = LOWORD(lParam) * tw / 100 - xoff;
+ dx = HIWORD(wParam) * tw / 100 - xoff;
break;
/* The next two are undocumented ! */
- case EM_GETTHUMB:
- ret = tw ? MAKELONG(xoff * 100 / tw, 0) : 0;
+ case EM_GETTHUMB16:
+ ret = tw ? xoff * 100 / tw : 0;
break;
- case EM_LINESCROLL:
- dx = LOWORD(lParam);
+ case EM_LINESCROLL16:
+ dx = (INT16)HIWORD(wParam);
break;
case SB_ENDSCROLL:
default:
break;
}
if (dx) {
- EDIT_EM_LineScroll(wndPtr, 0, MAKELPARAM(0, dx));
- if (not)
+ 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;
}
@@ -2481,17 +3162,18 @@
*/
static LRESULT EDIT_WM_KeyDown(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- UINT s = LOWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT e = HIWORD(EDIT_GetSel(wndPtr, 0, 0L));
- BOOL shift;
- BOOL control;
+ INT32 s;
+ INT32 e;
+ BOOL32 shift;
+ BOOL32 control;
if (GetKeyState(VK_MENU) & 0x8000)
- return 0L;
+ return 0;
shift = GetKeyState(VK_SHIFT) & 0x8000;
control = GetKeyState(VK_CONTROL) & 0x8000;
+ EDIT_GetSel(wndPtr, &s, &e);
switch (wParam) {
case VK_LEFT:
case VK_UP:
@@ -2529,7 +3211,7 @@
case VK_BACK:
if (!IsReadOnly(wndPtr) && !control)
if (e != s)
- EDIT_WM_Clear(wndPtr, 0, 0L);
+ EDIT_WM_Clear(wndPtr, 0, 0);
else
EDIT_DelLeft(wndPtr);
break;
@@ -2537,9 +3219,9 @@
if (!IsReadOnly(wndPtr) && !(shift && control))
if (e != s) {
if (shift)
- EDIT_WM_Cut(wndPtr, 0, 0L);
+ EDIT_WM_Cut(wndPtr, 0, 0);
else
- EDIT_WM_Clear(wndPtr, 0, 0L);
+ EDIT_WM_Clear(wndPtr, 0, 0);
} else {
if (shift)
EDIT_DelLeft(wndPtr);
@@ -2552,12 +3234,12 @@
case VK_INSERT:
if (shift) {
if (!IsReadOnly(wndPtr))
- EDIT_WM_Paste(wndPtr, 0, 0L);
+ EDIT_WM_Paste(wndPtr, 0, 0);
} else if (control)
- EDIT_WM_Copy(wndPtr, 0, 0L);
+ EDIT_WM_Copy(wndPtr, 0, 0);
break;
}
- return 0L;
+ return 0;
}
@@ -2568,17 +3250,17 @@
*/
static LRESULT EDIT_WM_KillFocus(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- UINT s;
- UINT e;
+ INT32 s;
+ INT32 e;
DestroyCaret();
if(!(wndPtr->dwStyle & ES_NOHIDESEL)) {
- s = LOWORD(EDIT_GetSel(wndPtr, 0, 0L));
- e = HIWORD(EDIT_GetSel(wndPtr, 0, 0L));
+ EDIT_GetSel(wndPtr, &s, &e);
EDIT_InvalidateText(wndPtr, s, e);
}
+ dprintf_edit(stddeb, "edit: notification EN_KILLFOCUS sent\n");
EDIT_NOTIFY_PARENT(wndPtr, EN_KILLFOCUS);
- return 0L;
+ return 0;
}
@@ -2591,17 +3273,22 @@
*/
static LRESULT EDIT_WM_LButtonDblClk(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- UINT s;
- UINT e = HIWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT l = (UINT)EDIT_EM_LineFromChar(wndPtr, e, 0L);
- UINT li = (UINT)EDIT_EM_LineIndex(wndPtr, l, 0L);
- UINT ll = (UINT)EDIT_EM_LineLength(wndPtr, e, 0L);
- char *text = EDIT_GetPointer(wndPtr);
+ 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, 0);
+ li = (INT32)EDIT_EM_LineIndex(wndPtr, l, 0);
+ ll = (INT32)EDIT_EM_LineLength(wndPtr, e, 0);
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, 0, MAKELPARAM(s, e));
- return 0L;
+ EDIT_EM_SetSel(wndPtr, s, e);
+ EDIT_EM_ScrollCaret(wndPtr, 0, 0);
+ return 0;
}
@@ -2612,29 +3299,30 @@
*/
static LRESULT EDIT_WM_LButtonDown(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- INT x = (INT)LOWORD(lParam);
- INT y = (INT)HIWORD(lParam);
- UINT l = EDIT_LineFromWndY(wndPtr, y);
- UINT c;
- UINT s;
- UINT e;
- UINT fv = (UINT)EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0L);
- UINT vlc = EDIT_GetVisibleLineCount(wndPtr);
- UINT li;
+ 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, 0, 0);
+ 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 = (UINT)EDIT_EM_LineIndex(wndPtr, l, 0L);
+ li = (INT32)EDIT_EM_LineIndex(wndPtr, l, 0);
e = li + c;
if (GetKeyState(VK_SHIFT) & 0x8000)
- s = LOWORD(EDIT_GetSel(wndPtr, 0, 0L));
- else
+ EDIT_GetSel(wndPtr, &s, NULL);
+ else
s = e;
- EDIT_EM_SetSel(wndPtr, 0, MAKELPARAM(s, e));
- return 0L;
+ EDIT_EM_SetSel(wndPtr, s, e);
+ EDIT_EM_ScrollCaret(wndPtr, 0, 0);
+ return 0;
}
@@ -2647,7 +3335,7 @@
{
if (GetCapture32() == wndPtr->hwndSelf)
ReleaseCapture();
- return 0L;
+ return 0;
}
@@ -2658,29 +3346,29 @@
*/
static LRESULT EDIT_WM_MouseMove(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- INT x;
- INT y;
- UINT l;
- UINT c;
- UINT s;
- UINT fv;
- UINT vlc;
- UINT li;
+ INT32 x;
+ INT32 y;
+ INT32 l;
+ INT32 c;
+ INT32 s;
+ INT32 fv;
+ INT32 vlc;
+ INT32 li;
if (GetCapture32() == wndPtr->hwndSelf) {
- x = (INT)LOWORD(lParam);
- y = (INT)HIWORD(lParam);
- fv = (UINT)EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0L);
+ x = (INT32)(INT16)LOWORD(lParam);
+ y = (INT32)(INT16)HIWORD(lParam);
+ fv = (INT32)EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0);
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);
- s = LOWORD(EDIT_GetSel(wndPtr, 0, 0L));
- li = (UINT)EDIT_EM_LineIndex(wndPtr, l, 0L);
- EDIT_EM_SetSel(wndPtr, 1, MAKELPARAM(s, li + c));
+ EDIT_GetSel(wndPtr, &s, NULL);
+ li = (INT32)EDIT_EM_LineIndex(wndPtr, l, 0);
+ EDIT_EM_SetSel(wndPtr, s, li + c);
}
- return 0L;
+ return 0;
}
@@ -2691,38 +3379,39 @@
*/
static LRESULT EDIT_WM_Paint(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- PAINTSTRUCT16 ps;
- UINT i;
- UINT fv = (UINT)EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0L);
- UINT vlc = EDIT_GetVisibleLineCount(wndPtr);
- UINT lc = (UINT)EDIT_EM_GetLineCount(wndPtr, 0, 0L);
- HDC16 hdc;
- HFONT16 hFont;
+ PAINTSTRUCT32 ps;
+ INT32 i;
+ INT32 fv = (INT32)EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0);
+ INT32 vlc = EDIT_GetVisibleLineCount(wndPtr);
+ INT32 lc = (INT32)EDIT_EM_GetLineCount(wndPtr, 0, 0);
+ HDC32 hdc;
+ HFONT32 hFont;
HFONT32 oldFont = 0;
- RECT16 rc;
- RECT16 rcLine;
- RECT16 rcRgn;
- BOOL rev = IsWindowEnabled(wndPtr->hwndSelf) &&
+ RECT32 rc;
+ RECT32 rcLine;
+ RECT32 rcRgn;
+ BOOL32 rev = IsWindowEnabled(wndPtr->hwndSelf) &&
((GetFocus32() == wndPtr->hwndSelf) ||
(wndPtr->dwStyle & ES_NOHIDESEL));
- hdc = BeginPaint16(wndPtr->hwndSelf, &ps);
- GetClientRect16(wndPtr->hwndSelf, &rc);
- IntersectClipRect16( hdc, rc.left, rc.top, rc.right, rc.bottom );
- hFont = EDIT_WM_GetFont(wndPtr, 0, 0L);
- if (hFont) oldFont = SelectObject32(hdc, hFont);
+ 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, 0, 0);
+ if (hFont)
+ oldFont = (HFONT32)SelectObject32(hdc, hFont);
EDIT_SEND_CTLCOLOR(wndPtr, hdc);
if (!IsWindowEnabled(wndPtr->hwndSelf))
SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
- GetClipBox16(hdc, &rcRgn);
+ GetClipBox32(hdc, &rcRgn);
for (i = fv ; i <= MIN(fv + vlc, fv + lc - 1) ; i++ ) {
EDIT_GetLineRect(wndPtr, i, 0, -1, &rcLine);
- if (IntersectRect16(&rc, &rcRgn, &rcLine))
+ if (IntersectRect32(&rc, &rcRgn, &rcLine))
EDIT_PaintLine(wndPtr, hdc, i, rev);
}
if (hFont) SelectObject32(hdc, oldFont);
- EndPaint16(wndPtr->hwndSelf, &ps);
- return 0L;
+ EndPaint32(wndPtr->hwndSelf, &ps);
+ return 0;
}
@@ -2734,16 +3423,16 @@
static LRESULT EDIT_WM_Paste(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
HGLOBAL16 hsrc;
- char *src;
+ LPSTR src;
OpenClipboard(wndPtr->hwndSelf);
if ((hsrc = GetClipboardData(CF_TEXT))) {
- src = (char *)GlobalLock16(hsrc);
- EDIT_ReplaceSel(wndPtr, 0, (LPARAM)src);
+ src = (LPSTR)GlobalLock16(hsrc);
+ EDIT_EM_ReplaceSel(wndPtr, 0, (LPARAM)src);
GlobalUnlock16(hsrc);
}
CloseClipboard();
- return -1L;
+ return -1;
}
@@ -2756,9 +3445,9 @@
{
if (LOWORD(lParam) == HTCLIENT) {
SetCursor(LoadCursor16(0, IDC_IBEAM));
- return -1L;
+ return -1;
} else
- return 0L;
+ return 0;
}
@@ -2769,16 +3458,18 @@
*/
static LRESULT EDIT_WM_SetFocus(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- UINT s = LOWORD(EDIT_GetSel(wndPtr, 0, 0L));
- UINT e = HIWORD(EDIT_GetSel(wndPtr, 0, 0L));
+ INT32 s;
+ INT32 e;
+ EDIT_GetSel(wndPtr, &s, &e);
CreateCaret(wndPtr->hwndSelf, 0, 2, EDIT_GetLineHeight(wndPtr));
- EDIT_EM_SetSel(wndPtr, 1, MAKELPARAM(s, e));
+ EDIT_EM_SetSel(wndPtr, s, e);
if(!(wndPtr->dwStyle & ES_NOHIDESEL))
EDIT_InvalidateText(wndPtr, s, e);
ShowCaret(wndPtr->hwndSelf);
+ dprintf_edit(stddeb, "edit: notification EN_SETFOCUS sent\n");
EDIT_NOTIFY_PARENT(wndPtr, EN_SETFOCUS);
- return 0L;
+ return 0;
}
@@ -2789,30 +3480,32 @@
*/
static LRESULT EDIT_WM_SetFont(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- TEXTMETRIC16 tm;
+ TEXTMETRIC32A tm;
EDITSTATE *es = EDITSTATEPTR(wndPtr);
- LPARAM sel = EDIT_GetSel(wndPtr, 0, 0L);
+ INT32 s;
+ INT32 e;
HDC32 hdc;
HFONT32 oldFont = 0;
- es->hFont = (HFONT16)wParam;
+ EDIT_GetSel(wndPtr, &s, &e);
+ es->hFont = (HFONT32)wParam;
hdc = GetDC32(wndPtr->hwndSelf);
if (es->hFont) oldFont = SelectObject32(hdc, es->hFont);
- GetTextMetrics16(hdc, &tm);
- es->LineHeight = HIWORD(GetTextExtent(hdc, "X", 1));
+ 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 ((BOOL)lParam && EDIT_GetRedraw(wndPtr))
+ if ((BOOL32)lParam && EDIT_GetRedraw(wndPtr))
InvalidateRect32( wndPtr->hwndSelf, NULL, TRUE );
if (wndPtr->hwndSelf == GetFocus32()) {
DestroyCaret();
CreateCaret(wndPtr->hwndSelf, 0, 2, EDIT_GetLineHeight(wndPtr));
- EDIT_EM_SetSel(wndPtr, 1, sel);
+ EDIT_EM_SetSel16(wndPtr, s, e);
ShowCaret(wndPtr->hwndSelf);
}
- return 0L;
+ return 0;
}
@@ -2825,8 +3518,8 @@
{
EDITSTATE *es = EDITSTATEPTR(wndPtr);
- es->Redraw = (BOOL)wParam;
- return 0L;
+ es->Redraw = (BOOL32)wParam;
+ return 0;
}
@@ -2837,14 +3530,15 @@
*/
static LRESULT EDIT_WM_SetText(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- EDIT_EM_SetSel(wndPtr, 1, MAKELPARAM(0, -1));
- EDIT_WM_Clear(wndPtr, 0, 0L);
+ EDIT_EM_SetSel(wndPtr, 0, -1);
if (lParam)
EDIT_EM_ReplaceSel(wndPtr, 0, lParam);
- EDIT_EM_EmptyUndoBuffer(wndPtr, 0, 0L);
- EDIT_EM_SetModify(wndPtr, TRUE, 0L);
- EDIT_ScrollIntoView(wndPtr);
- return 0L;
+ else
+ EDIT_WM_Clear(wndPtr, 0, 0);
+ EDIT_EM_EmptyUndoBuffer(wndPtr, 0, 0);
+ EDIT_EM_SetModify(wndPtr, TRUE, 0);
+ EDIT_EM_ScrollCaret(wndPtr, 0, 0);
+ return 1;
}
@@ -2852,9 +3546,14 @@
*
* WM_SIZE
*
+ * FIXME: What about that FormatRect ???
+ *
*/
static LRESULT EDIT_WM_Size(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
+ EDITSTATE *es = EDITSTATEPTR(wndPtr);
+
+ GetClientRect32(wndPtr->hwndSelf, &es->FormatRect);
if (EDIT_GetRedraw(wndPtr) &&
((wParam == SIZE_MAXIMIZED) ||
(wParam == SIZE_RESTORED))) {
@@ -2862,7 +3561,7 @@
EDIT_BuildLineDefs(wndPtr);
InvalidateRect32( wndPtr->hwndSelf, NULL, TRUE );
}
- return 0L;
+ return 0;
}
@@ -2875,12 +3574,12 @@
*/
static LRESULT EDIT_WM_VScroll(WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
{
- UINT lc = (UINT)EDIT_EM_GetLineCount(wndPtr, 0, 0L);
- UINT fv = (UINT)EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0L);
- UINT vlc = EDIT_GetVisibleLineCount(wndPtr);
- INT dy = 0;
- BOOL not = TRUE;
- LRESULT ret = 0L;
+ INT32 lc = (INT32)EDIT_EM_GetLineCount(wndPtr, 0, 0);
+ INT32 fv = (INT32)EDIT_EM_GetFirstVisibleLine(wndPtr, 0, 0);
+ INT32 vlc = EDIT_GetVisibleLineCount(wndPtr);
+ INT32 dy = 0;
+ BOOL32 not = TRUE;
+ LRESULT ret = 0;
switch (wParam) {
case SB_LINEUP:
@@ -2902,27 +3601,28 @@
dy = lc - 1 - fv;
break;
case SB_THUMBTRACK:
-/*
- * not = FALSE;
- */
+ not = FALSE;
+ /* fall through */
case SB_THUMBPOSITION:
- dy = LOWORD(lParam) * (lc - 1) / 100 - fv;
+ dy = HIWORD(wParam) * (lc - 1) / 100 - fv;
break;
/* The next two are undocumented ! */
- case EM_GETTHUMB:
- ret = (lc > 1) ? MAKELONG(fv * 100 / (lc - 1), 0) : 0L;
+ case EM_GETTHUMB16:
+ ret = (lc > 1) ? MAKELONG(fv * 100 / (lc - 1), 0) : 0;
break;
- case EM_LINESCROLL:
- dy = LOWORD(lParam);
+ case EM_LINESCROLL16:
+ dy = (INT16)LOWORD(lParam);
break;
case SB_ENDSCROLL:
default:
break;
}
if (dy) {
- EDIT_EM_LineScroll(wndPtr, 0, MAKELPARAM(dy, 0));
- if (not)
+ 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;
}
