?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Solve remaining problems with scroll bars in the edit control.
[wine.git] / controls / edit.c
blob57ed054ed4c130941b162073fca188496e30e2d7
1 /*
2 * Edit control
3 *
4 * Copyright David W. Metcalfe, 1994
5 * Copyright William Magro, 1995, 1996
6 * Copyright Frans van Dorsselaer, 1996, 1997
7 *
8 */
9
10 /*
11 * please read EDIT.TODO (and update it when you change things)
12 */
13
14 #include "config.h"
15
16 #include <string.h>
17 #include <stdlib.h>
18
19 #include "winbase.h"
20 #include "winnt.h"
21 #include "win.h"
22 #include "wine/winbase16.h"
23 #include "wine/winuser16.h"
24 #include "wine/unicode.h"
25 #include "controls.h"
26 #include "local.h"
27 #include "user.h"
28 #include "debugtools.h"
29
30 DEFAULT_DEBUG_CHANNEL(edit);
31 DECLARE_DEBUG_CHANNEL(combo);
32 DECLARE_DEBUG_CHANNEL(relay);
33
34 #define BUFLIMIT_MULTI 65534 /* maximum buffer size (not including '\0')
35 FIXME: BTW, new specs say 65535 (do you dare ???) */
36 #define BUFLIMIT_SINGLE 32766 /* maximum buffer size (not including '\0') */
37 #define GROWLENGTH 32 /* buffers granularity in bytes: must be power of 2 */
38 #define ROUND_TO_GROW(size) (((size) + (GROWLENGTH - 1)) & ~(GROWLENGTH - 1))
39 #define HSCROLL_FRACTION 3 /* scroll window by 1/3 width */
40
41 /*
42 * extra flags for EDITSTATE.flags field
43 */
44 #define EF_MODIFIED 0x0001 /* text has been modified */
45 #define EF_FOCUSED 0x0002 /* we have input focus */
46 #define EF_UPDATE 0x0004 /* notify parent of changed state on next WM_PAINT */
47 #define EF_VSCROLL_TRACK 0x0008 /* don't SetScrollPos() since we are tracking the thumb */
48 #define EF_HSCROLL_TRACK 0x0010 /* don't SetScrollPos() since we are tracking the thumb */
49 #define EF_AFTER_WRAP 0x0080 /* the caret is displayed after the last character of a
50 wrapped line, instead of in front of the next character */
51 #define EF_USE_SOFTBRK 0x0100 /* Enable soft breaks in text. */
52
53 typedef enum
54 {
55 END_0 = 0, /* line ends with terminating '\0' character */
56 END_WRAP, /* line is wrapped */
57 END_HARD, /* line ends with a hard return '\r\n' */
58 END_SOFT /* line ends with a soft return '\r\r\n' */
59 } LINE_END;
60
61 typedef struct tagLINEDEF {
62 INT length; /* bruto length of a line in bytes */
63 INT net_length; /* netto length of a line in visible characters */
64 LINE_END ending;
65 INT width; /* width of the line in pixels */
66 struct tagLINEDEF *next;
67 } LINEDEF;
68
69 typedef struct
70 {
71 BOOL is_unicode; /* how the control was created */
72 LPWSTR text; /* the actual contents of the control */
73 UINT buffer_size; /* the size of the buffer in characters */
74 UINT buffer_limit; /* the maximum size to which the buffer may grow in characters */
75 HFONT font; /* NULL means standard system font */
76 INT x_offset; /* scroll offset for multi lines this is in pixels
77 for single lines it's in characters */
78 INT line_height; /* height of a screen line in pixels */
79 INT char_width; /* average character width in pixels */
80 DWORD style; /* sane version of wnd->dwStyle */
81 WORD flags; /* flags that are not in es->style or wnd->flags (EF_XXX) */
82 INT undo_insert_count; /* number of characters inserted in sequence */
83 UINT undo_position; /* character index of the insertion and deletion */
84 LPWSTR undo_text; /* deleted text */
85 UINT undo_buffer_size; /* size of the deleted text buffer */
86 INT selection_start; /* == selection_end if no selection */
87 INT selection_end; /* == current caret position */
88 WCHAR password_char; /* == 0 if no password char, and for multi line controls */
89 INT left_margin; /* in pixels */
90 INT right_margin; /* in pixels */
91 RECT format_rect;
92 INT text_width; /* width of the widest line in pixels for multi line controls
93 and just line width for single line controls */
94 INT region_posx; /* Position of cursor relative to region: */
95 INT region_posy; /* -1: to left, 0: within, 1: to right */
96 EDITWORDBREAKPROC16 word_break_proc16;
97 void *word_break_proc; /* 32-bit word break proc: ANSI or Unicode */
98 INT line_count; /* number of lines */
99 INT y_offset; /* scroll offset in number of lines */
100 BOOL bCaptureState; /* flag indicating whether mouse was captured */
101 BOOL bEnableState; /* flag keeping the enable state */
102 HWND hwndListBox; /* handle of ComboBox's listbox or NULL */
103 /*
104 * only for multi line controls
105 */
106 INT lock_count; /* amount of re-entries in the EditWndProc */
107 INT tabs_count;
108 LPINT tabs;
109 LINEDEF *first_line_def; /* linked list of (soft) linebreaks */
110 HLOCAL hloc32W; /* our unicode local memory block */
111 HLOCAL16 hloc16; /* alias for 16-bit control receiving EM_GETHANDLE16
112 or EM_SETHANDLE16 */
113 HLOCAL hloc32A; /* alias for ANSI control receiving EM_GETHANDLE
114 or EM_SETHANDLE */
115 } EDITSTATE;
116
117
118 #define SWAP_INT32(x,y) do { INT temp = (INT)(x); (x) = (INT)(y); (y) = temp; } while(0)
119 #define ORDER_INT(x,y) do { if ((INT)(y) < (INT)(x)) SWAP_INT32((x),(y)); } while(0)
120
121 #define SWAP_UINT32(x,y) do { UINT temp = (UINT)(x); (x) = (UINT)(y); (y) = temp; } while(0)
122 #define ORDER_UINT(x,y) do { if ((UINT)(y) < (UINT)(x)) SWAP_UINT32((x),(y)); } while(0)
123
124 #define DPRINTF_EDIT_NOTIFY(hwnd, str) \
125 do {TRACE("notification " str " sent to hwnd=%08x\n", \
126 (UINT)(hwnd));} while(0)
127
128 /* used for disabled or read-only edit control */
129 #define EDIT_SEND_CTLCOLORSTATIC(wnd,hdc) \
130 (SendMessageW((wnd)->parent->hwndSelf, WM_CTLCOLORSTATIC, \
131 (WPARAM)(hdc), (LPARAM)(wnd)->hwndSelf))
132 #define EDIT_SEND_CTLCOLOR(wnd,hdc) \
133 (SendMessageW((wnd)->parent->hwndSelf, WM_CTLCOLOREDIT, \
134 (WPARAM)(hdc), (LPARAM)(wnd)->hwndSelf))
135 #define EDIT_NOTIFY_PARENT(wnd, wNotifyCode, str) \
136 do {DPRINTF_EDIT_NOTIFY((wnd)->parent->hwndSelf, str); \
137 SendMessageW((wnd)->parent->hwndSelf, WM_COMMAND, \
138 MAKEWPARAM((wnd)->wIDmenu, wNotifyCode), \
139 (LPARAM)(wnd)->hwndSelf);} while(0)
140 #define DPRINTF_EDIT_MSG16(str) \
141 TRACE(\
142 "16 bit : " str ": hwnd=%08x, wParam=%08x, lParam=%08x\n", \
143 (UINT)wnd->hwndSelf, (UINT)wParam, (UINT)lParam)
144 #define DPRINTF_EDIT_MSG32(str) \
145 TRACE(\
146 "32 bit %c : " str ": hwnd=%08x, wParam=%08x, lParam=%08x\n", \
147 unicode ? 'W' : 'A', \
148 (UINT)wnd->hwndSelf, (UINT)wParam, (UINT)lParam)
149
150 /*********************************************************************
151 *
152 * Declarations
153 *
154 */
155
156 /*
157 * These functions have trivial implementations
158 * We still like to call them internally
159 * "static inline" makes them more like macro's
160 */
161 static inline BOOL EDIT_EM_CanUndo(EDITSTATE *es);
162 static inline void EDIT_EM_EmptyUndoBuffer(EDITSTATE *es);
163 static inline void EDIT_WM_Clear(WND *wnd, EDITSTATE *es);
164 static inline void EDIT_WM_Cut(WND *wnd, EDITSTATE *es);
165
166 /*
167 * Helper functions only valid for one type of control
168 */
169 static void EDIT_BuildLineDefs_ML(WND *wnd, EDITSTATE *es);
170 static void EDIT_CalcLineWidth_SL(WND *wnd, EDITSTATE *es);
171 static LPWSTR EDIT_GetPasswordPointer_SL(EDITSTATE *es);
172 static void EDIT_MoveDown_ML(WND *wnd, EDITSTATE *es, BOOL extend);
173 static void EDIT_MovePageDown_ML(WND *wnd, EDITSTATE *es, BOOL extend);
174 static void EDIT_MovePageUp_ML(WND *wnd, EDITSTATE *es, BOOL extend);
175 static void EDIT_MoveUp_ML(WND *wnd, EDITSTATE *es, BOOL extend);
176 /*
177 * Helper functions valid for both single line _and_ multi line controls
178 */
179 static INT EDIT_CallWordBreakProc(EDITSTATE *es, INT start, INT index, INT count, INT action);
180 static INT EDIT_CharFromPos(WND *wnd, EDITSTATE *es, INT x, INT y, LPBOOL after_wrap);
181 static void EDIT_ConfinePoint(EDITSTATE *es, LPINT x, LPINT y);
182 static void EDIT_GetLineRect(WND *wnd, EDITSTATE *es, INT line, INT scol, INT ecol, LPRECT rc);
183 static void EDIT_InvalidateText(WND *wnd, EDITSTATE *es, INT start, INT end);
184 static void EDIT_LockBuffer(WND *wnd, EDITSTATE *es);
185 static BOOL EDIT_MakeFit(WND *wnd, EDITSTATE *es, UINT size);
186 static BOOL EDIT_MakeUndoFit(EDITSTATE *es, UINT size);
187 static void EDIT_MoveBackward(WND *wnd, EDITSTATE *es, BOOL extend);
188 static void EDIT_MoveEnd(WND *wnd, EDITSTATE *es, BOOL extend);
189 static void EDIT_MoveForward(WND *wnd, EDITSTATE *es, BOOL extend);
190 static void EDIT_MoveHome(WND *wnd, EDITSTATE *es, BOOL extend);
191 static void EDIT_MoveWordBackward(WND *wnd, EDITSTATE *es, BOOL extend);
192 static void EDIT_MoveWordForward(WND *wnd, EDITSTATE *es, BOOL extend);
193 static void EDIT_PaintLine(WND *wnd, EDITSTATE *es, HDC hdc, INT line, BOOL rev);
194 static INT EDIT_PaintText(EDITSTATE *es, HDC hdc, INT x, INT y, INT line, INT col, INT count, BOOL rev);
195 static void EDIT_SetCaretPos(WND *wnd, EDITSTATE *es, INT pos, BOOL after_wrap);
196 static void EDIT_SetRectNP(WND *wnd, EDITSTATE *es, LPRECT lprc);
197 static void EDIT_UnlockBuffer(WND *wnd, EDITSTATE *es, BOOL force);
198 static void EDIT_UpdateScrollInfo(WND *wnd, EDITSTATE *es);
199 static INT CALLBACK EDIT_WordBreakProc(LPWSTR s, INT index, INT count, INT action);
200 /*
201 * EM_XXX message handlers
202 */
203 static LRESULT EDIT_EM_CharFromPos(WND *wnd, EDITSTATE *es, INT x, INT y);
204 static BOOL EDIT_EM_FmtLines(EDITSTATE *es, BOOL add_eol);
205 static HLOCAL EDIT_EM_GetHandle(EDITSTATE *es);
206 static HLOCAL16 EDIT_EM_GetHandle16(WND *wnd, EDITSTATE *es);
207 static INT EDIT_EM_GetLine(EDITSTATE *es, INT line, LPWSTR lpch);
208 static LRESULT EDIT_EM_GetSel(EDITSTATE *es, LPUINT start, LPUINT end);
209 static LRESULT EDIT_EM_GetThumb(WND *wnd, EDITSTATE *es);
210 static INT EDIT_EM_LineFromChar(EDITSTATE *es, INT index);
211 static INT EDIT_EM_LineIndex(EDITSTATE *es, INT line);
212 static INT EDIT_EM_LineLength(EDITSTATE *es, INT index);
213 static BOOL EDIT_EM_LineScroll(WND *wnd, EDITSTATE *es, INT dx, INT dy);
214 static BOOL EDIT_EM_LineScroll_internal(WND *wnd, EDITSTATE *es, INT dx, INT dy);
215 static LRESULT EDIT_EM_PosFromChar(WND *wnd, EDITSTATE *es, INT index, BOOL after_wrap);
216 static void EDIT_EM_ReplaceSel(WND *wnd, EDITSTATE *es, BOOL can_undo, LPCWSTR lpsz_replace, BOOL send_update);
217 static LRESULT EDIT_EM_Scroll(WND *wnd, EDITSTATE *es, INT action);
218 static void EDIT_EM_ScrollCaret(WND *wnd, EDITSTATE *es);
219 static void EDIT_EM_SetHandle(WND *wnd, EDITSTATE *es, HLOCAL hloc);
220 static void EDIT_EM_SetHandle16(WND *wnd, EDITSTATE *es, HLOCAL16 hloc);
221 static void EDIT_EM_SetLimitText(EDITSTATE *es, INT limit);
222 static void EDIT_EM_SetMargins(EDITSTATE *es, INT action, INT left, INT right);
223 static void EDIT_EM_SetPasswordChar(WND *wnd, EDITSTATE *es, WCHAR c);
224 static void EDIT_EM_SetSel(WND *wnd, EDITSTATE *es, UINT start, UINT end, BOOL after_wrap);
225 static BOOL EDIT_EM_SetTabStops(EDITSTATE *es, INT count, LPINT tabs);
226 static BOOL EDIT_EM_SetTabStops16(EDITSTATE *es, INT count, LPINT16 tabs);
227 static void EDIT_EM_SetWordBreakProc(WND *wnd, EDITSTATE *es, LPARAM lParam);
228 static void EDIT_EM_SetWordBreakProc16(WND *wnd, EDITSTATE *es, EDITWORDBREAKPROC16 wbp);
229 static BOOL EDIT_EM_Undo(WND *wnd, EDITSTATE *es);
230 /*
231 * WM_XXX message handlers
232 */
233 static void EDIT_WM_Char(WND *wnd, EDITSTATE *es, WCHAR c);
234 static void EDIT_WM_Command(WND *wnd, EDITSTATE *es, INT code, INT id, HWND conrtol);
235 static void EDIT_WM_ContextMenu(WND *wnd, EDITSTATE *es, INT x, INT y);
236 static void EDIT_WM_Copy(WND *wnd, EDITSTATE *es);
237 static LRESULT EDIT_WM_Create(WND *wnd, EDITSTATE *es, LPCWSTR name);
238 static void EDIT_WM_Destroy(WND *wnd, EDITSTATE *es);
239 static LRESULT EDIT_WM_EraseBkGnd(WND *wnd, EDITSTATE *es, HDC dc);
240 static INT EDIT_WM_GetText(EDITSTATE *es, INT count, LPARAM lParam, BOOL unicode);
241 static LRESULT EDIT_WM_HScroll(WND *wnd, EDITSTATE *es, INT action, INT pos);
242 static LRESULT EDIT_WM_KeyDown(WND *wnd, EDITSTATE *es, INT key);
243 static LRESULT EDIT_WM_KillFocus(WND *wnd, EDITSTATE *es);
244 static LRESULT EDIT_WM_LButtonDblClk(WND *wnd, EDITSTATE *es);
245 static LRESULT EDIT_WM_LButtonDown(WND *wnd, EDITSTATE *es, DWORD keys, INT x, INT y);
246 static LRESULT EDIT_WM_LButtonUp(HWND hwndSelf, EDITSTATE *es);
247 static LRESULT EDIT_WM_MButtonDown(WND *wnd);
248 static LRESULT EDIT_WM_MouseMove(WND *wnd, EDITSTATE *es, INT x, INT y);
249 static LRESULT EDIT_WM_NCCreate(WND *wnd, DWORD style, HWND hwndParent, BOOL unicode);
250 static void EDIT_WM_Paint(WND *wnd, EDITSTATE *es, WPARAM wParam);
251 static void EDIT_WM_Paste(WND *wnd, EDITSTATE *es);
252 static void EDIT_WM_SetFocus(WND *wnd, EDITSTATE *es);
253 static void EDIT_WM_SetFont(WND *wnd, EDITSTATE *es, HFONT font, BOOL redraw);
254 static void EDIT_WM_SetText(WND *wnd, EDITSTATE *es, LPARAM lParam, BOOL unicode);
255 static void EDIT_WM_Size(WND *wnd, EDITSTATE *es, UINT action, INT width, INT height);
256 static LRESULT EDIT_WM_SysKeyDown(WND *wnd, EDITSTATE *es, INT key, DWORD key_data);
257 static void EDIT_WM_Timer(WND *wnd, EDITSTATE *es);
258 static LRESULT EDIT_WM_VScroll(WND *wnd, EDITSTATE *es, INT action, INT pos);
259 static void EDIT_UpdateText(WND *wnd, LPRECT rc, BOOL bErase);
260
261 LRESULT WINAPI EditWndProcA(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
262 LRESULT WINAPI EditWndProcW(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
263
264 /*********************************************************************
265 * edit class descriptor
266 */
267 const struct builtin_class_descr EDIT_builtin_class =
268 {
269 "Edit", /* name */
270 CS_GLOBALCLASS | CS_DBLCLKS /*| CS_PARENTDC*/, /* style */
271 EditWndProcA, /* procA */
272 EditWndProcW, /* procW */
273 sizeof(EDITSTATE *), /* extra */
274 IDC_IBEAMA, /* cursor */
275 0 /* brush */
276 };
277
278
279 /*********************************************************************
280 *
281 * EM_CANUNDO
282 *
283 */
284 static inline BOOL EDIT_EM_CanUndo(EDITSTATE *es)
285 {
286 return (es->undo_insert_count || strlenW(es->undo_text));
287 }
288
289
290 /*********************************************************************
291 *
292 * EM_EMPTYUNDOBUFFER
293 *
294 */
295 static inline void EDIT_EM_EmptyUndoBuffer(EDITSTATE *es)
296 {
297 es->undo_insert_count = 0;
298 *es->undo_text = '\0';
299 }
300
301
302 /*********************************************************************
303 *
304 * WM_CLEAR
305 *
306 */
307 static inline void EDIT_WM_Clear(WND *wnd, EDITSTATE *es)
308 {
309 static const WCHAR empty_stringW[] = {0};
310
311 EDIT_EM_ReplaceSel(wnd, es, TRUE, empty_stringW, TRUE);
312
313 if (es->flags & EF_UPDATE) {
314 es->flags &= ~EF_UPDATE;
315 EDIT_NOTIFY_PARENT(wnd, EN_CHANGE, "EN_CHANGE");
316 }
317 }
318
319
320 /*********************************************************************
321 *
322 * WM_CUT
323 *
324 */
325 static inline void EDIT_WM_Cut(WND *wnd, EDITSTATE *es)
326 {
327 EDIT_WM_Copy(wnd, es);
328 EDIT_WM_Clear(wnd, es);
329 }
330
331
332 /**********************************************************************
333 * get_app_version
334 *
335 * Returns the window version in case Wine emulates a later version
336 * of windows then the application expects.
337 *
338 * In a number of cases when windows runs an application that was
339 * designed for an earlier windows version, windows reverts
340 * to "old" behaviour of that earlier version.
341 *
342 * An example is a disabled edit control that needs to be painted.
343 * Old style behaviour is to send a WM_CTLCOLOREDIT message. This was
344 * changed in Win95, NT4.0 by a WM_CTLCOLORSTATIC message _only_ for
345 * applications with an expected version 0f 4.0 or higher.
346 *
347 */
348 static DWORD get_app_version(void)
349 {
350 static DWORD version;
351 if (!version)
352 {
353 DWORD dwEmulatedVersion;
354 OSVERSIONINFOW info;
355 DWORD dwProcVersion = GetProcessVersion(0);
356
357 GetVersionExW( &info );
358 dwEmulatedVersion = MAKELONG( info.dwMinorVersion, info.dwMajorVersion );
359 /* fixme: this may not be 100% correct; see discussion on the
360 * wine developer list in Nov 1999 */
361 version = dwProcVersion < dwEmulatedVersion ? dwProcVersion : dwEmulatedVersion;
362 }
363 return version;
364 }
365
366
367 /*********************************************************************
368 *
369 * EditWndProc_locked
370 *
371 * The messages are in the order of the actual integer values
372 * (which can be found in include/windows.h)
373 * Whereever possible the 16 bit versions are converted to
374 * the 32 bit ones, so that we can 'fall through' to the
375 * helper functions. These are mostly 32 bit (with a few
376 * exceptions, clearly indicated by a '16' extension to their
377 * names).
378 *
379 */
380 static LRESULT WINAPI EditWndProc_locked( WND *wnd, UINT msg,
381 WPARAM wParam, LPARAM lParam, BOOL unicode )
382 {
383 EDITSTATE *es = *(EDITSTATE **)((wnd)->wExtra);
384 LRESULT result = 0;
385
386 switch (msg) {
387 case WM_DESTROY:
388 DPRINTF_EDIT_MSG32("WM_DESTROY");
389 EDIT_WM_Destroy(wnd, es);
390 result = 0;
391 goto END;
392
393 case WM_NCCREATE:
394 DPRINTF_EDIT_MSG32("WM_NCCREATE");
395 if(unicode)
396 {
397 LPCREATESTRUCTW cs = (LPCREATESTRUCTW)lParam;
398 result = EDIT_WM_NCCreate(wnd, cs->style, cs->hwndParent, TRUE);
399 }
400 else
401 {
402 LPCREATESTRUCTA cs = (LPCREATESTRUCTA)lParam;
403 result = EDIT_WM_NCCreate(wnd, cs->style, cs->hwndParent, FALSE);
404 }
405 goto END;
406 }
407
408 if (!es)
409 {
410 if(unicode)
411 result = DefWindowProcW(wnd->hwndSelf, msg, wParam, lParam);
412 else
413 result = DefWindowProcA(wnd->hwndSelf, msg, wParam, lParam);
414 goto END;
415 }
416
417
418 EDIT_LockBuffer(wnd, es);
419 switch (msg) {
420 case EM_GETSEL16:
421 DPRINTF_EDIT_MSG16("EM_GETSEL");
422 wParam = 0;
423 lParam = 0;
424 /* fall through */
425 case EM_GETSEL:
426 DPRINTF_EDIT_MSG32("EM_GETSEL");
427 result = EDIT_EM_GetSel(es, (LPUINT)wParam, (LPUINT)lParam);
428 break;
429
430 case EM_SETSEL16:
431 DPRINTF_EDIT_MSG16("EM_SETSEL");
432 if (SLOWORD(lParam) == -1)
433 EDIT_EM_SetSel(wnd, es, (UINT)-1, 0, FALSE);
434 else
435 EDIT_EM_SetSel(wnd, es, LOWORD(lParam), HIWORD(lParam), FALSE);
436 if (!wParam)
437 EDIT_EM_ScrollCaret(wnd, es);
438 result = 1;
439 break;
440 case EM_SETSEL:
441 DPRINTF_EDIT_MSG32("EM_SETSEL");
442 EDIT_EM_SetSel(wnd, es, wParam, lParam, FALSE);
443 EDIT_EM_ScrollCaret(wnd, es);
444 result = 1;
445 break;
446
447 case EM_GETRECT16:
448 DPRINTF_EDIT_MSG16("EM_GETRECT");
449 if (lParam)
450 CONV_RECT32TO16(&es->format_rect, MapSL(lParam));
451 break;
452 case EM_GETRECT:
453 DPRINTF_EDIT_MSG32("EM_GETRECT");
454 if (lParam)
455 CopyRect((LPRECT)lParam, &es->format_rect);
456 break;
457
458 case EM_SETRECT16:
459 DPRINTF_EDIT_MSG16("EM_SETRECT");
460 if ((es->style & ES_MULTILINE) && lParam) {
461 RECT rc;
462 CONV_RECT16TO32(MapSL(lParam), &rc);
463 EDIT_SetRectNP(wnd, es, &rc);
464 EDIT_UpdateText(wnd, NULL, TRUE);
465 }
466 break;
467 case EM_SETRECT:
468 DPRINTF_EDIT_MSG32("EM_SETRECT");
469 if ((es->style & ES_MULTILINE) && lParam) {
470 EDIT_SetRectNP(wnd, es, (LPRECT)lParam);
471 EDIT_UpdateText(wnd, NULL, TRUE);
472 }
473 break;
474
475 case EM_SETRECTNP16:
476 DPRINTF_EDIT_MSG16("EM_SETRECTNP");
477 if ((es->style & ES_MULTILINE) && lParam) {
478 RECT rc;
479 CONV_RECT16TO32(MapSL(lParam), &rc);
480 EDIT_SetRectNP(wnd, es, &rc);
481 }
482 break;
483 case EM_SETRECTNP:
484 DPRINTF_EDIT_MSG32("EM_SETRECTNP");
485 if ((es->style & ES_MULTILINE) && lParam)
486 EDIT_SetRectNP(wnd, es, (LPRECT)lParam);
487 break;
488
489 case EM_SCROLL16:
490 DPRINTF_EDIT_MSG16("EM_SCROLL");
491 /* fall through */
492 case EM_SCROLL:
493 DPRINTF_EDIT_MSG32("EM_SCROLL");
494 result = EDIT_EM_Scroll(wnd, es, (INT)wParam);
495 break;
496
497 case EM_LINESCROLL16:
498 DPRINTF_EDIT_MSG16("EM_LINESCROLL");
499 wParam = (WPARAM)(INT)SHIWORD(lParam);
500 lParam = (LPARAM)(INT)SLOWORD(lParam);
501 /* fall through */
502 case EM_LINESCROLL:
503 DPRINTF_EDIT_MSG32("EM_LINESCROLL");
504 result = (LRESULT)EDIT_EM_LineScroll(wnd, es, (INT)wParam, (INT)lParam);
505 break;
506
507 case EM_SCROLLCARET16:
508 DPRINTF_EDIT_MSG16("EM_SCROLLCARET");
509 /* fall through */
510 case EM_SCROLLCARET:
511 DPRINTF_EDIT_MSG32("EM_SCROLLCARET");
512 EDIT_EM_ScrollCaret(wnd, es);
513 result = 1;
514 break;
515
516 case EM_GETMODIFY16:
517 DPRINTF_EDIT_MSG16("EM_GETMODIFY");
518 /* fall through */
519 case EM_GETMODIFY:
520 DPRINTF_EDIT_MSG32("EM_GETMODIFY");
521 result = ((es->flags & EF_MODIFIED) != 0);
522 break;
523
524 case EM_SETMODIFY16:
525 DPRINTF_EDIT_MSG16("EM_SETMODIFY");
526 /* fall through */
527 case EM_SETMODIFY:
528 DPRINTF_EDIT_MSG32("EM_SETMODIFY");
529 if (wParam)
530 es->flags |= EF_MODIFIED;
531 else
532 es->flags &= ~(EF_MODIFIED | EF_UPDATE); /* reset pending updates */
533 break;
534
535 case EM_GETLINECOUNT16:
536 DPRINTF_EDIT_MSG16("EM_GETLINECOUNT");
537 /* fall through */
538 case EM_GETLINECOUNT:
539 DPRINTF_EDIT_MSG32("EM_GETLINECOUNT");
540 result = (es->style & ES_MULTILINE) ? es->line_count : 1;
541 break;
542
543 case EM_LINEINDEX16:
544 DPRINTF_EDIT_MSG16("EM_LINEINDEX");
545 if ((INT16)wParam == -1)
546 wParam = (WPARAM)-1;
547 /* fall through */
548 case EM_LINEINDEX:
549 DPRINTF_EDIT_MSG32("EM_LINEINDEX");
550 result = (LRESULT)EDIT_EM_LineIndex(es, (INT)wParam);
551 break;
552
553 case EM_SETHANDLE16:
554 DPRINTF_EDIT_MSG16("EM_SETHANDLE");
555 EDIT_EM_SetHandle16(wnd, es, (HLOCAL16)wParam);
556 break;
557 case EM_SETHANDLE:
558 DPRINTF_EDIT_MSG32("EM_SETHANDLE");
559 EDIT_EM_SetHandle(wnd, es, (HLOCAL)wParam);
560 break;
561
562 case EM_GETHANDLE16:
563 DPRINTF_EDIT_MSG16("EM_GETHANDLE");
564 result = (LRESULT)EDIT_EM_GetHandle16(wnd, es);
565 break;
566 case EM_GETHANDLE:
567 DPRINTF_EDIT_MSG32("EM_GETHANDLE");
568 result = (LRESULT)EDIT_EM_GetHandle(es);
569 break;
570
571 case EM_GETTHUMB16:
572 DPRINTF_EDIT_MSG16("EM_GETTHUMB");
573 /* fall through */
574 case EM_GETTHUMB:
575 DPRINTF_EDIT_MSG32("EM_GETTHUMB");
576 result = EDIT_EM_GetThumb(wnd, es);
577 break;
578
579 /* messages 0x00bf and 0x00c0 missing from specs */
580
581 case WM_USER+15:
582 DPRINTF_EDIT_MSG16("undocumented WM_USER+15, please report");
583 /* fall through */
584 case 0x00bf:
585 DPRINTF_EDIT_MSG32("undocumented 0x00bf, please report");
586 if(unicode)
587 result = DefWindowProcW(wnd->hwndSelf, msg, wParam, lParam);
588 else
589 result = DefWindowProcA(wnd->hwndSelf, msg, wParam, lParam);
590 break;
591
592 case WM_USER+16:
593 DPRINTF_EDIT_MSG16("undocumented WM_USER+16, please report");
594 /* fall through */
595 case 0x00c0:
596 DPRINTF_EDIT_MSG32("undocumented 0x00c0, please report");
597 if(unicode)
598 result = DefWindowProcW(wnd->hwndSelf, msg, wParam, lParam);
599 else
600 result = DefWindowProcA(wnd->hwndSelf, msg, wParam, lParam);
601 break;
602
603 case EM_LINELENGTH16:
604 DPRINTF_EDIT_MSG16("EM_LINELENGTH");
605 /* fall through */
606 case EM_LINELENGTH:
607 DPRINTF_EDIT_MSG32("EM_LINELENGTH");
608 result = (LRESULT)EDIT_EM_LineLength(es, (INT)wParam);
609 break;
610
611 case EM_REPLACESEL16:
612 DPRINTF_EDIT_MSG16("EM_REPLACESEL");
613 lParam = (LPARAM)MapSL(lParam);
614 /* fall through */
615 case EM_REPLACESEL:
616 {
617 LPWSTR textW;
618 DPRINTF_EDIT_MSG32("EM_REPLACESEL");
619
620 if(unicode)
621 textW = (LPWSTR)lParam;
622 else
623 {
624 LPSTR textA = (LPSTR)lParam;
625 INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
626 if((textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
627 MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
628 }
629
630 EDIT_EM_ReplaceSel(wnd, es, (BOOL)wParam, textW, TRUE);
631 if (es->flags & EF_UPDATE) {
632 es->flags &= ~EF_UPDATE;
633 EDIT_NOTIFY_PARENT(wnd, EN_CHANGE, "EN_CHANGE");
634 }
635 result = 1;
636
637 if(!unicode)
638 HeapFree(GetProcessHeap(), 0, textW);
639 break;
640 }
641 /* message 0x00c3 missing from specs */
642
643 case WM_USER+19:
644 DPRINTF_EDIT_MSG16("undocumented WM_USER+19, please report");
645 /* fall through */
646 case 0x00c3:
647 DPRINTF_EDIT_MSG32("undocumented 0x00c3, please report");
648 if(unicode)
649 result = DefWindowProcW(wnd->hwndSelf, msg, wParam, lParam);
650 else
651 result = DefWindowProcA(wnd->hwndSelf, msg, wParam, lParam);
652 break;
653
654 case EM_GETLINE16:
655 DPRINTF_EDIT_MSG16("EM_GETLINE");
656 lParam = (LPARAM)MapSL(lParam);
657 /* fall through */
658 case EM_GETLINE:
659 DPRINTF_EDIT_MSG32("EM_GETLINE");
660 result = (LRESULT)EDIT_EM_GetLine(es, (INT)wParam, (LPWSTR)lParam);
661 break;
662
663 case EM_LIMITTEXT16:
664 DPRINTF_EDIT_MSG16("EM_LIMITTEXT");
665 /* fall through */
666 case EM_SETLIMITTEXT:
667 DPRINTF_EDIT_MSG32("EM_SETLIMITTEXT");
668 EDIT_EM_SetLimitText(es, (INT)wParam);
669 break;
670
671 case EM_CANUNDO16:
672 DPRINTF_EDIT_MSG16("EM_CANUNDO");
673 /* fall through */
674 case EM_CANUNDO:
675 DPRINTF_EDIT_MSG32("EM_CANUNDO");
676 result = (LRESULT)EDIT_EM_CanUndo(es);
677 break;
678
679 case EM_UNDO16:
680 DPRINTF_EDIT_MSG16("EM_UNDO");
681 /* fall through */
682 case EM_UNDO:
683 /* fall through */
684 case WM_UNDO:
685 DPRINTF_EDIT_MSG32("EM_UNDO / WM_UNDO");
686 result = (LRESULT)EDIT_EM_Undo(wnd, es);
687 break;
688
689 case EM_FMTLINES16:
690 DPRINTF_EDIT_MSG16("EM_FMTLINES");
691 /* fall through */
692 case EM_FMTLINES:
693 DPRINTF_EDIT_MSG32("EM_FMTLINES");
694 result = (LRESULT)EDIT_EM_FmtLines(es, (BOOL)wParam);
695 break;
696
697 case EM_LINEFROMCHAR16:
698 DPRINTF_EDIT_MSG16("EM_LINEFROMCHAR");
699 /* fall through */
700 case EM_LINEFROMCHAR:
701 DPRINTF_EDIT_MSG32("EM_LINEFROMCHAR");
702 result = (LRESULT)EDIT_EM_LineFromChar(es, (INT)wParam);
703 break;
704
705 /* message 0x00ca missing from specs */
706
707 case WM_USER+26:
708 DPRINTF_EDIT_MSG16("undocumented WM_USER+26, please report");
709 /* fall through */
710 case 0x00ca:
711 DPRINTF_EDIT_MSG32("undocumented 0x00ca, please report");
712 if(unicode)
713 result = DefWindowProcW(wnd->hwndSelf, msg, wParam, lParam);
714 else
715 result = DefWindowProcA(wnd->hwndSelf, msg, wParam, lParam);
716 break;
717
718 case EM_SETTABSTOPS16:
719 DPRINTF_EDIT_MSG16("EM_SETTABSTOPS");
720 result = (LRESULT)EDIT_EM_SetTabStops16(es, (INT)wParam, MapSL(lParam));
721 break;
722 case EM_SETTABSTOPS:
723 DPRINTF_EDIT_MSG32("EM_SETTABSTOPS");
724 result = (LRESULT)EDIT_EM_SetTabStops(es, (INT)wParam, (LPINT)lParam);
725 break;
726
727 case EM_SETPASSWORDCHAR16:
728 DPRINTF_EDIT_MSG16("EM_SETPASSWORDCHAR");
729 /* fall through */
730 case EM_SETPASSWORDCHAR:
731 {
732 WCHAR charW = 0;
733 DPRINTF_EDIT_MSG32("EM_SETPASSWORDCHAR");
734
735 if(unicode)
736 charW = (WCHAR)wParam;
737 else
738 {
739 CHAR charA = wParam;
740 MultiByteToWideChar(CP_ACP, 0, &charA, 1, &charW, 1);
741 }
742
743 EDIT_EM_SetPasswordChar(wnd, es, charW);
744 break;
745 }
746
747 case EM_EMPTYUNDOBUFFER16:
748 DPRINTF_EDIT_MSG16("EM_EMPTYUNDOBUFFER");
749 /* fall through */
750 case EM_EMPTYUNDOBUFFER:
751 DPRINTF_EDIT_MSG32("EM_EMPTYUNDOBUFFER");
752 EDIT_EM_EmptyUndoBuffer(es);
753 break;
754
755 case EM_GETFIRSTVISIBLELINE16:
756 DPRINTF_EDIT_MSG16("EM_GETFIRSTVISIBLELINE");
757 result = es->y_offset;
758 break;
759 case EM_GETFIRSTVISIBLELINE:
760 DPRINTF_EDIT_MSG32("EM_GETFIRSTVISIBLELINE");
761 result = (es->style & ES_MULTILINE) ? es->y_offset : es->x_offset;
762 break;
763
764 case EM_SETREADONLY16:
765 DPRINTF_EDIT_MSG16("EM_SETREADONLY");
766 /* fall through */
767 case EM_SETREADONLY:
768 DPRINTF_EDIT_MSG32("EM_SETREADONLY");
769 if (wParam) {
770 wnd->dwStyle |= ES_READONLY;
771 es->style |= ES_READONLY;
772 } else {
773 wnd->dwStyle &= ~ES_READONLY;
774 es->style &= ~ES_READONLY;
775 }
776 result = 1;
777 break;
778
779 case EM_SETWORDBREAKPROC16:
780 DPRINTF_EDIT_MSG16("EM_SETWORDBREAKPROC");
781 EDIT_EM_SetWordBreakProc16(wnd, es, (EDITWORDBREAKPROC16)lParam);
782 break;
783 case EM_SETWORDBREAKPROC:
784 DPRINTF_EDIT_MSG32("EM_SETWORDBREAKPROC");
785 EDIT_EM_SetWordBreakProc(wnd, es, lParam);
786 break;
787
788 case EM_GETWORDBREAKPROC16:
789 DPRINTF_EDIT_MSG16("EM_GETWORDBREAKPROC");
790 result = (LRESULT)es->word_break_proc16;
791 break;
792 case EM_GETWORDBREAKPROC:
793 DPRINTF_EDIT_MSG32("EM_GETWORDBREAKPROC");
794 result = (LRESULT)es->word_break_proc;
795 break;
796
797 case EM_GETPASSWORDCHAR16:
798 DPRINTF_EDIT_MSG16("EM_GETPASSWORDCHAR");
799 /* fall through */
800 case EM_GETPASSWORDCHAR:
801 {
802 DPRINTF_EDIT_MSG32("EM_GETPASSWORDCHAR");
803
804 if(unicode)
805 result = es->password_char;
806 else
807 {
808 WCHAR charW = es->password_char;
809 CHAR charA = 0;
810 WideCharToMultiByte(CP_ACP, 0, &charW, 1, &charA, 1, NULL, NULL);
811 result = charA;
812 }
813 break;
814 }
815
816 /* The following EM_xxx are new to win95 and don't exist for 16 bit */
817
818 case EM_SETMARGINS:
819 DPRINTF_EDIT_MSG32("EM_SETMARGINS");
820 EDIT_EM_SetMargins(es, (INT)wParam, SLOWORD(lParam), SHIWORD(lParam));
821 break;
822
823 case EM_GETMARGINS:
824 DPRINTF_EDIT_MSG32("EM_GETMARGINS");
825 result = MAKELONG(es->left_margin, es->right_margin);
826 break;
827
828 case EM_GETLIMITTEXT:
829 DPRINTF_EDIT_MSG32("EM_GETLIMITTEXT");
830 result = es->buffer_limit;
831 break;
832
833 case EM_POSFROMCHAR:
834 DPRINTF_EDIT_MSG32("EM_POSFROMCHAR");
835 result = EDIT_EM_PosFromChar(wnd, es, (INT)wParam, FALSE);
836 break;
837
838 case EM_CHARFROMPOS:
839 DPRINTF_EDIT_MSG32("EM_CHARFROMPOS");
840 result = EDIT_EM_CharFromPos(wnd, es, SLOWORD(lParam), SHIWORD(lParam));
841 break;
842
843 case WM_GETDLGCODE:
844 DPRINTF_EDIT_MSG32("WM_GETDLGCODE");
845 result = DLGC_HASSETSEL | DLGC_WANTCHARS | DLGC_WANTARROWS;
846
847 if (lParam && (((LPMSG)lParam)->message == WM_KEYDOWN))
848 {
849 int vk = (int)((LPMSG)lParam)->wParam;
850
851 if ((wnd->dwStyle & ES_WANTRETURN) && vk == VK_RETURN)
852 {
853 result |= DLGC_WANTMESSAGE;
854 }
855 else if (es->hwndListBox && (vk == VK_RETURN || vk == VK_ESCAPE))
856 {
857 if (SendMessageW(wnd->parent->hwndSelf, CB_GETDROPPEDSTATE, 0, 0))
858 result |= DLGC_WANTMESSAGE;
859 }
860 }
861 break;
862
863 case WM_CHAR:
864 {
865 WCHAR charW;
866 DPRINTF_EDIT_MSG32("WM_CHAR");
867
868 if(unicode)
869 charW = wParam;
870 else
871 {
872 CHAR charA = wParam;
873 MultiByteToWideChar(CP_ACP, 0, &charA, 1, &charW, 1);
874 }
875
876 if ((charW == VK_RETURN || charW == VK_ESCAPE) && es->hwndListBox)
877 {
878 if (SendMessageW(wnd->parent->hwndSelf, CB_GETDROPPEDSTATE, 0, 0))
879 SendMessageW(wnd->parent->hwndSelf, WM_KEYDOWN, charW, 0);
880 break;
881 }
882 EDIT_WM_Char(wnd, es, charW);
883 break;
884 }
885
886 case WM_CLEAR:
887 DPRINTF_EDIT_MSG32("WM_CLEAR");
888 EDIT_WM_Clear(wnd, es);
889 break;
890
891 case WM_COMMAND:
892 DPRINTF_EDIT_MSG32("WM_COMMAND");
893 EDIT_WM_Command(wnd, es, HIWORD(wParam), LOWORD(wParam), (HWND)lParam);
894 break;
895
896 case WM_CONTEXTMENU:
897 DPRINTF_EDIT_MSG32("WM_CONTEXTMENU");
898 EDIT_WM_ContextMenu(wnd, es, SLOWORD(lParam), SHIWORD(lParam));
899 break;
900
901 case WM_COPY:
902 DPRINTF_EDIT_MSG32("WM_COPY");
903 EDIT_WM_Copy(wnd, es);
904 break;
905
906 case WM_CREATE:
907 DPRINTF_EDIT_MSG32("WM_CREATE");
908 if(unicode)
909 result = EDIT_WM_Create(wnd, es, ((LPCREATESTRUCTW)lParam)->lpszName);
910 else
911 {
912 LPCSTR nameA = ((LPCREATESTRUCTA)lParam)->lpszName;
913 LPWSTR nameW = NULL;
914 if(nameA)
915 {
916 INT countW = MultiByteToWideChar(CP_ACP, 0, nameA, -1, NULL, 0);
917 if((nameW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
918 MultiByteToWideChar(CP_ACP, 0, nameA, -1, nameW, countW);
919 }
920 result = EDIT_WM_Create(wnd, es, nameW);
921 if(nameW)
922 HeapFree(GetProcessHeap(), 0, nameW);
923 }
924 break;
925
926 case WM_CUT:
927 DPRINTF_EDIT_MSG32("WM_CUT");
928 EDIT_WM_Cut(wnd, es);
929 break;
930
931 case WM_ENABLE:
932 DPRINTF_EDIT_MSG32("WM_ENABLE");
933 es->bEnableState = (BOOL) wParam;
934 EDIT_UpdateText(wnd, NULL, TRUE);
935 break;
936
937 case WM_ERASEBKGND:
938 DPRINTF_EDIT_MSG32("WM_ERASEBKGND");
939 result = EDIT_WM_EraseBkGnd(wnd, es, (HDC)wParam);
940 break;
941
942 case WM_GETFONT:
943 DPRINTF_EDIT_MSG32("WM_GETFONT");
944 result = (LRESULT)es->font;
945 break;
946
947 case WM_GETTEXT:
948 DPRINTF_EDIT_MSG32("WM_GETTEXT");
949 result = (LRESULT)EDIT_WM_GetText(es, (INT)wParam, lParam, unicode);
950 break;
951
952 case WM_GETTEXTLENGTH:
953 DPRINTF_EDIT_MSG32("WM_GETTEXTLENGTH");
954 result = strlenW(es->text);
955 break;
956
957 case WM_HSCROLL:
958 DPRINTF_EDIT_MSG32("WM_HSCROLL");
959 result = EDIT_WM_HScroll(wnd, es, LOWORD(wParam), SHIWORD(wParam));
960 break;
961
962 case WM_KEYDOWN:
963 DPRINTF_EDIT_MSG32("WM_KEYDOWN");
964 result = EDIT_WM_KeyDown(wnd, es, (INT)wParam);
965 break;
966
967 case WM_KILLFOCUS:
968 DPRINTF_EDIT_MSG32("WM_KILLFOCUS");
969 result = EDIT_WM_KillFocus(wnd, es);
970 break;
971
972 case WM_LBUTTONDBLCLK:
973 DPRINTF_EDIT_MSG32("WM_LBUTTONDBLCLK");
974 result = EDIT_WM_LButtonDblClk(wnd, es);
975 break;
976
977 case WM_LBUTTONDOWN:
978 DPRINTF_EDIT_MSG32("WM_LBUTTONDOWN");
979 result = EDIT_WM_LButtonDown(wnd, es, (DWORD)wParam, SLOWORD(lParam), SHIWORD(lParam));
980 break;
981
982 case WM_LBUTTONUP:
983 DPRINTF_EDIT_MSG32("WM_LBUTTONUP");
984 result = EDIT_WM_LButtonUp(wnd->hwndSelf, es);
985 break;
986
987 case WM_MBUTTONDOWN:
988 DPRINTF_EDIT_MSG32("WM_MBUTTONDOWN");
989 result = EDIT_WM_MButtonDown(wnd);
990 break;
991
992 case WM_MOUSEACTIVATE:
993 /*
994 * FIXME: maybe DefWindowProc() screws up, but it seems that
995 * modeless dialog boxes need this. If we don't do this, the focus
996 * will _not_ be set by DefWindowProc() for edit controls in a
997 * modeless dialog box ???
998 */
999 DPRINTF_EDIT_MSG32("WM_MOUSEACTIVATE");
1000 SetFocus(wnd->hwndSelf);
1001 result = MA_ACTIVATE;
1002 break;
1003
1004 case WM_MOUSEMOVE:
1005 /*
1006 * DPRINTF_EDIT_MSG32("WM_MOUSEMOVE");
1007 */
1008 result = EDIT_WM_MouseMove(wnd, es, SLOWORD(lParam), SHIWORD(lParam));
1009 break;
1010
1011 case WM_PAINT:
1012 DPRINTF_EDIT_MSG32("WM_PAINT");
1013 EDIT_WM_Paint(wnd, es, wParam);
1014 break;
1015
1016 case WM_PASTE:
1017 DPRINTF_EDIT_MSG32("WM_PASTE");
1018 EDIT_WM_Paste(wnd, es);
1019 break;
1020
1021 case WM_SETFOCUS:
1022 DPRINTF_EDIT_MSG32("WM_SETFOCUS");
1023 EDIT_WM_SetFocus(wnd, es);
1024 break;
1025
1026 case WM_SETFONT:
1027 DPRINTF_EDIT_MSG32("WM_SETFONT");
1028 EDIT_WM_SetFont(wnd, es, (HFONT)wParam, LOWORD(lParam) != 0);
1029 break;
1030
1031 case WM_SETREDRAW:
1032 /* FIXME: actually set an internal flag and behave accordingly */
1033 break;
1034
1035 case WM_SETTEXT:
1036 DPRINTF_EDIT_MSG32("WM_SETTEXT");
1037 EDIT_WM_SetText(wnd, es, lParam, unicode);
1038 result = TRUE;
1039 break;
1040
1041 case WM_SIZE:
1042 DPRINTF_EDIT_MSG32("WM_SIZE");
1043 EDIT_WM_Size(wnd, es, (UINT)wParam, LOWORD(lParam), HIWORD(lParam));
1044 break;
1045
1046 case WM_SYSKEYDOWN:
1047 DPRINTF_EDIT_MSG32("WM_SYSKEYDOWN");
1048 result = EDIT_WM_SysKeyDown(wnd, es, (INT)wParam, (DWORD)lParam);
1049 break;
1050
1051 case WM_TIMER:
1052 DPRINTF_EDIT_MSG32("WM_TIMER");
1053 EDIT_WM_Timer(wnd, es);
1054 break;
1055
1056 case WM_VSCROLL:
1057 DPRINTF_EDIT_MSG32("WM_VSCROLL");
1058 result = EDIT_WM_VScroll(wnd, es, LOWORD(wParam), SHIWORD(wParam));
1059 break;
1060
1061 case WM_MOUSEWHEEL:
1062 {
1063 int gcWheelDelta = 0;
1064 UINT pulScrollLines = 3;
1065 SystemParametersInfoW(SPI_GETWHEELSCROLLLINES,0, &pulScrollLines, 0);
1066
1067 if (wParam & (MK_SHIFT | MK_CONTROL)) {
1068 if(unicode)
1069 result = DefWindowProcW(wnd->hwndSelf, msg, wParam, lParam);
1070 else
1071 result = DefWindowProcA(wnd->hwndSelf, msg, wParam, lParam);
1072 break;
1073 }
1074 gcWheelDelta -= SHIWORD(wParam);
1075 if (abs(gcWheelDelta) >= WHEEL_DELTA && pulScrollLines)
1076 {
1077 int cLineScroll= (int) min((UINT) es->line_count, pulScrollLines);
1078 cLineScroll *= (gcWheelDelta / WHEEL_DELTA);
1079 result = EDIT_EM_LineScroll(wnd, es, 0, cLineScroll);
1080 }
1081 }
1082 break;
1083 default:
1084 if(unicode)
1085 result = DefWindowProcW(wnd->hwndSelf, msg, wParam, lParam);
1086 else
1087 result = DefWindowProcA(wnd->hwndSelf, msg, wParam, lParam);
1088 break;
1089 }
1090 EDIT_UnlockBuffer(wnd, es, FALSE);
1091 END:
1092 return result;
1093 }
1094
1095 /*********************************************************************
1096 *
1097 * EditWndProcW (USER32.@)
1098 */
1099 LRESULT WINAPI EditWndProcW(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1100 {
1101 LRESULT res;
1102 WND *wndPtr = WIN_FindWndPtr(hWnd);
1103
1104 res = EditWndProc_locked(wndPtr, uMsg, wParam, lParam, TRUE);
1105
1106 WIN_ReleaseWndPtr(wndPtr);
1107 return res;
1108 }
1109
1110 /*********************************************************************
1111 *
1112 * EditWndProcA (USER32.@)
1113 */
1114 LRESULT WINAPI EditWndProcA(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1115 {
1116 LRESULT res;
1117 WND *wndPtr = WIN_FindWndPtr(hWnd);
1118
1119 res = EditWndProc_locked(wndPtr, uMsg, wParam, lParam, FALSE);
1120
1121 WIN_ReleaseWndPtr(wndPtr);
1122 return res;
1123 }
1124
1125 /*********************************************************************
1126 *
1127 * EDIT_BuildLineDefs_ML
1128 *
1129 * Build linked list of text lines.
1130 * Lines can end with '\0' (last line), a character (if it is wrapped),
1131 * a soft return '\r\r\n' or a hard return '\r\n'
1132 *
1133 */
1134 static void EDIT_BuildLineDefs_ML(WND *wnd, EDITSTATE *es)
1135 {
1136 HDC dc;
1137 HFONT old_font = 0;
1138 LPWSTR start, cp;
1139 INT fw;
1140 LINEDEF *current_def;
1141 LINEDEF **previous_next;
1142
1143 current_def = es->first_line_def;
1144 do {
1145 LINEDEF *next_def = current_def->next;
1146 HeapFree(GetProcessHeap(), 0, current_def);
1147 current_def = next_def;
1148 } while (current_def);
1149 es->line_count = 0;
1150 es->text_width = 0;
1151
1152 dc = GetDC(wnd->hwndSelf);
1153 if (es->font)
1154 old_font = SelectObject(dc, es->font);
1155
1156 fw = es->format_rect.right - es->format_rect.left;
1157 start = es->text;
1158 previous_next = &es->first_line_def;
1159 do {
1160 current_def = HeapAlloc(GetProcessHeap(), 0, sizeof(LINEDEF));
1161 current_def->next = NULL;
1162 cp = start;
1163 while (*cp) {
1164 if ((*cp == '\r') && (*(cp + 1) == '\n'))
1165 break;
1166 cp++;
1167 }
1168 if (!(*cp)) {
1169 current_def->ending = END_0;
1170 current_def->net_length = strlenW(start);
1171 } else if ((cp > start) && (*(cp - 1) == '\r')) {
1172 current_def->ending = END_SOFT;
1173 current_def->net_length = cp - start - 1;
1174 } else {
1175 current_def->ending = END_HARD;
1176 current_def->net_length = cp - start;
1177 }
1178 current_def->width = (INT)LOWORD(GetTabbedTextExtentW(dc,
1179 start, current_def->net_length,
1180 es->tabs_count, es->tabs));
1181 /* FIXME: check here for lines that are too wide even in AUTOHSCROLL (> 32767 ???) */
1182 if ((!(es->style & ES_AUTOHSCROLL)) && (current_def->width > fw)) {
1183 INT next = 0;
1184 INT prev;
1185 do {
1186 prev = next;
1187 next = EDIT_CallWordBreakProc(es, start - es->text,
1188 prev + 1, current_def->net_length, WB_RIGHT);
1189 current_def->width = (INT)LOWORD(GetTabbedTextExtentW(dc,
1190 start, next, es->tabs_count, es->tabs));
1191 } while (current_def->width <= fw);
1192 if (!prev) {
1193 next = 0;
1194 do {
1195 prev = next;
1196 next++;
1197 current_def->width = (INT)LOWORD(GetTabbedTextExtentW(dc,
1198 start, next, es->tabs_count, es->tabs));
1199 } while (current_def->width <= fw);
1200 if (!prev)
1201 prev = 1;
1202 }
1203 current_def->net_length = prev;
1204 current_def->ending = END_WRAP;
1205 current_def->width = (INT)LOWORD(GetTabbedTextExtentW(dc, start,
1206 current_def->net_length, es->tabs_count, es->tabs));
1207 }
1208 switch (current_def->ending) {
1209 case END_SOFT:
1210 current_def->length = current_def->net_length + 3;
1211 break;
1212 case END_HARD:
1213 current_def->length = current_def->net_length + 2;
1214 break;
1215 case END_WRAP:
1216 case END_0:
1217 current_def->length = current_def->net_length;
1218 break;
1219 }
1220 es->text_width = max(es->text_width, current_def->width);
1221 start += current_def->length;
1222 *previous_next = current_def;
1223 previous_next = &current_def->next;
1224 es->line_count++;
1225 } while (current_def->ending != END_0);
1226 if (es->font)
1227 SelectObject(dc, old_font);
1228 ReleaseDC(wnd->hwndSelf, dc);
1229 }
1230
1231 /*********************************************************************
1232 *
1233 * EDIT_CalcLineWidth_SL
1234 *
1235 */
1236 static void EDIT_CalcLineWidth_SL(WND *wnd, EDITSTATE *es)
1237 {
1238 es->text_width = SLOWORD(EDIT_EM_PosFromChar(wnd, es, strlenW(es->text), FALSE));
1239 }
1240
1241 /*********************************************************************
1242 *
1243 * EDIT_CallWordBreakProc
1244 *
1245 * Call appropriate WordBreakProc (internal or external).
1246 *
1247 * Note: The "start" argument should always be an index refering
1248 * to es->text. The actual wordbreak proc might be
1249 * 16 bit, so we can't always pass any 32 bit LPSTR.
1250 * Hence we assume that es->text is the buffer that holds
1251 * the string under examination (we can decide this for ourselves).
1252 *
1253 */
1254 /* ### start build ### */
1255 extern WORD CALLBACK EDIT_CallTo16_word_lwww(EDITWORDBREAKPROC16,SEGPTR,WORD,WORD,WORD);
1256 /* ### stop build ### */
1257 static INT EDIT_CallWordBreakProc(EDITSTATE *es, INT start, INT index, INT count, INT action)
1258 {
1259 INT ret, iWndsLocks;
1260
1261 /* To avoid any deadlocks, all the locks on the windows structures
1262 must be suspended before the control is passed to the application */
1263 iWndsLocks = WIN_SuspendWndsLock();
1264
1265 if (es->word_break_proc16) {
1266 HGLOBAL16 hglob16;
1267 SEGPTR segptr;
1268 INT countA;
1269
1270 countA = WideCharToMultiByte(CP_ACP, 0, es->text + start, count, NULL, 0, NULL, NULL);
1271 hglob16 = GlobalAlloc16(GMEM_MOVEABLE | GMEM_ZEROINIT, countA);
1272 segptr = K32WOWGlobalLock16(hglob16);
1273 WideCharToMultiByte(CP_ACP, 0, es->text + start, count, MapSL(segptr), countA, NULL, NULL);
1274 ret = (INT)EDIT_CallTo16_word_lwww(es->word_break_proc16,
1275 segptr, index, countA, action);
1276 GlobalUnlock16(hglob16);
1277 GlobalFree16(hglob16);
1278 }
1279 else if (es->word_break_proc)
1280 {
1281 if(es->is_unicode)
1282 {
1283 EDITWORDBREAKPROCW wbpW = (EDITWORDBREAKPROCW)es->word_break_proc;
1284
1285 TRACE_(relay)("(UNICODE wordbrk=%p,str=%s,idx=%d,cnt=%d,act=%d)\n",
1286 es->word_break_proc, debugstr_wn(es->text + start, count), index, count, action);
1287 ret = wbpW(es->text + start, index, count, action);
1288 }
1289 else
1290 {
1291 EDITWORDBREAKPROCA wbpA = (EDITWORDBREAKPROCA)es->word_break_proc;
1292 INT countA;
1293 CHAR *textA;
1294
1295 countA = WideCharToMultiByte(CP_ACP, 0, es->text + start, count, NULL, 0, NULL, NULL);
1296 textA = HeapAlloc(GetProcessHeap(), 0, countA);
1297 WideCharToMultiByte(CP_ACP, 0, es->text + start, count, textA, countA, NULL, NULL);
1298 TRACE_(relay)("(ANSI wordbrk=%p,str=%s,idx=%d,cnt=%d,act=%d)\n",
1299 es->word_break_proc, debugstr_an(textA, countA), index, countA, action);
1300 ret = wbpA(textA, index, countA, action);
1301 HeapFree(GetProcessHeap(), 0, textA);
1302 }
1303 }
1304 else
1305 ret = EDIT_WordBreakProc(es->text + start, index, count, action);
1306
1307 WIN_RestoreWndsLock(iWndsLocks);
1308 return ret;
1309 }
1310
1311
1312 /*********************************************************************
1313 *
1314 * EDIT_CharFromPos
1315 *
1316 * Beware: This is not the function called on EM_CHARFROMPOS
1317 * The position _can_ be outside the formatting / client
1318 * rectangle
1319 * The return value is only the character index
1320 *
1321 */
1322 static INT EDIT_CharFromPos(WND *wnd, EDITSTATE *es, INT x, INT y, LPBOOL after_wrap)
1323 {
1324 INT index;
1325 HDC dc;
1326 HFONT old_font = 0;
1327
1328 if (es->style & ES_MULTILINE) {
1329 INT line = (y - es->format_rect.top) / es->line_height + es->y_offset;
1330 INT line_index = 0;
1331 LINEDEF *line_def = es->first_line_def;
1332 INT low, high;
1333 while ((line > 0) && line_def->next) {
1334 line_index += line_def->length;
1335 line_def = line_def->next;
1336 line--;
1337 }
1338 x += es->x_offset - es->format_rect.left;
1339 if (x >= line_def->width) {
1340 if (after_wrap)
1341 *after_wrap = (line_def->ending == END_WRAP);
1342 return line_index + line_def->net_length;
1343 }
1344 if (x <= 0) {
1345 if (after_wrap)
1346 *after_wrap = FALSE;
1347 return line_index;
1348 }
1349 dc = GetDC(wnd->hwndSelf);
1350 if (es->font)
1351 old_font = SelectObject(dc, es->font);
1352 low = line_index + 1;
1353 high = line_index + line_def->net_length + 1;
1354 while (low < high - 1)
1355 {
1356 INT mid = (low + high) / 2;
1357 if (LOWORD(GetTabbedTextExtentW(dc, es->text + line_index,mid - line_index, es->tabs_count, es->tabs)) > x) high = mid;
1358 else low = mid;
1359 }
1360 index = low;
1361
1362 if (after_wrap)
1363 *after_wrap = ((index == line_index + line_def->net_length) &&
1364 (line_def->ending == END_WRAP));
1365 } else {
1366 LPWSTR text;
1367 SIZE size;
1368 if (after_wrap)
1369 *after_wrap = FALSE;
1370 x -= es->format_rect.left;
1371 if (!x)
1372 return es->x_offset;
1373 text = EDIT_GetPasswordPointer_SL(es);
1374 dc = GetDC(wnd->hwndSelf);
1375 if (es->font)
1376 old_font = SelectObject(dc, es->font);
1377 if (x < 0)
1378 {
1379 INT low = 0;
1380 INT high = es->x_offset;
1381 while (low < high - 1)
1382 {
1383 INT mid = (low + high) / 2;
1384 GetTextExtentPoint32W( dc, text + mid,
1385 es->x_offset - mid, &size );
1386 if (size.cx > -x) low = mid;
1387 else high = mid;
1388 }
1389 index = low;
1390 }
1391 else
1392 {
1393 INT low = es->x_offset;
1394 INT high = strlenW(es->text) + 1;
1395 while (low < high - 1)
1396 {
1397 INT mid = (low + high) / 2;
1398 GetTextExtentPoint32W( dc, text + es->x_offset,
1399 mid - es->x_offset, &size );
1400 if (size.cx > x) high = mid;
1401 else low = mid;
1402 }
1403 index = low;
1404 }
1405 if (es->style & ES_PASSWORD)
1406 HeapFree(GetProcessHeap(), 0, text);
1407 }
1408 if (es->font)
1409 SelectObject(dc, old_font);
1410 ReleaseDC(wnd->hwndSelf, dc);
1411 return index;
1412 }
1413
1414
1415 /*********************************************************************
1416 *
1417 * EDIT_ConfinePoint
1418 *
1419 * adjusts the point to be within the formatting rectangle
1420 * (so CharFromPos returns the nearest _visible_ character)
1421 *
1422 */
1423 static void EDIT_ConfinePoint(EDITSTATE *es, LPINT x, LPINT y)
1424 {
1425 *x = min(max(*x, es->format_rect.left), es->format_rect.right - 1);
1426 *y = min(max(*y, es->format_rect.top), es->format_rect.bottom - 1);
1427 }
1428
1429
1430 /*********************************************************************
1431 *
1432 * EDIT_GetLineRect
1433 *
1434 * Calculates the bounding rectangle for a line from a starting
1435 * column to an ending column.
1436 *
1437 */
1438 static void EDIT_GetLineRect(WND *wnd, EDITSTATE *es, INT line, INT scol, INT ecol, LPRECT rc)
1439 {
1440 INT line_index = EDIT_EM_LineIndex(es, line);
1441
1442 if (es->style & ES_MULTILINE)
1443 rc->top = es->format_rect.top + (line - es->y_offset) * es->line_height;
1444 else
1445 rc->top = es->format_rect.top;
1446 rc->bottom = rc->top + es->line_height;
1447 rc->left = (scol == 0) ? es->format_rect.left : SLOWORD(EDIT_EM_PosFromChar(wnd, es, line_index + scol, TRUE));
1448 rc->right = (ecol == -1) ? es->format_rect.right : SLOWORD(EDIT_EM_PosFromChar(wnd, es, line_index + ecol, TRUE));
1449 }
1450
1451
1452 /*********************************************************************
1453 *
1454 * EDIT_GetPasswordPointer_SL
1455 *
1456 * note: caller should free the (optionally) allocated buffer
1457 *
1458 */
1459 static LPWSTR EDIT_GetPasswordPointer_SL(EDITSTATE *es)
1460 {
1461 if (es->style & ES_PASSWORD) {
1462 INT len = strlenW(es->text);
1463 LPWSTR text = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
1464 text[len] = '\0';
1465 while(len) text[--len] = es->password_char;
1466 return text;
1467 } else
1468 return es->text;
1469 }
1470
1471
1472 /*********************************************************************
1473 *
1474 * EDIT_LockBuffer
1475 *
1476 * This acts as a LOCAL_Lock(), but it locks only once. This way
1477 * you can call it whenever you like, without unlocking.
1478 *
1479 */
1480 static void EDIT_LockBuffer(WND *wnd, EDITSTATE *es)
1481 {
1482 if (!es) {
1483 ERR("no EDITSTATE ... please report\n");
1484 return;
1485 }
1486 if (!es->text) {
1487 CHAR *textA = NULL;
1488 UINT countA = 0;
1489 BOOL _16bit = FALSE;
1490
1491 if(es->hloc32W)
1492 {
1493 if(es->hloc32A)
1494 {
1495 TRACE("Synchronizing with 32-bit ANSI buffer\n");
1496 textA = LocalLock(es->hloc32A);
1497 countA = strlen(textA) + 1;
1498 }
1499 else if(es->hloc16)
1500 {
1501 TRACE("Synchronizing with 16-bit ANSI buffer\n");
1502 textA = LOCAL_Lock(wnd->hInstance, es->hloc16);
1503 countA = strlen(textA) + 1;
1504 _16bit = TRUE;
1505 }
1506 }
1507 else {
1508 ERR("no buffer ... please report\n");
1509 return;
1510 }
1511
1512 if(textA)
1513 {
1514 HLOCAL hloc32W_new;
1515 UINT countW_new = MultiByteToWideChar(CP_ACP, 0, textA, countA, NULL, 0);
1516 TRACE("%d bytes translated to %d WCHARs\n", countA, countW_new);
1517 if(countW_new > es->buffer_size + 1)
1518 {
1519 UINT alloc_size = ROUND_TO_GROW(countW_new * sizeof(WCHAR));
1520 TRACE("Resizing 32-bit UNICODE buffer from %d+1 to %d WCHARs\n", es->buffer_size, countW_new);
1521 hloc32W_new = LocalReAlloc(es->hloc32W, alloc_size, LMEM_MOVEABLE | LMEM_ZEROINIT);
1522 if(hloc32W_new)
1523 {
1524 es->hloc32W = hloc32W_new;
1525 es->buffer_size = LocalSize(hloc32W_new)/sizeof(WCHAR) - 1;
1526 TRACE("Real new size %d+1 WCHARs\n", es->buffer_size);
1527 }
1528 else
1529 WARN("FAILED! Will synchronize partially\n");
1530 }
1531 }
1532
1533 /*TRACE("Locking 32-bit UNICODE buffer\n");*/
1534 es->text = LocalLock(es->hloc32W);
1535
1536 if(textA)
1537 {
1538 MultiByteToWideChar(CP_ACP, 0, textA, countA, es->text, es->buffer_size + 1);
1539 if(_16bit)
1540 LOCAL_Unlock(wnd->hInstance, es->hloc16);
1541 else
1542 LocalUnlock(es->hloc32A);
1543 }
1544 }
1545 es->lock_count++;
1546 }
1547
1548
1549 /*********************************************************************
1550 *
1551 * EDIT_SL_InvalidateText
1552 *
1553 * Called from EDIT_InvalidateText().
1554 * Does the job for single-line controls only.
1555 *
1556 */
1557 static void EDIT_SL_InvalidateText(WND *wnd, EDITSTATE *es, INT start, INT end)
1558 {
1559 RECT line_rect;
1560 RECT rc;
1561
1562 EDIT_GetLineRect(wnd, es, 0, start, end, &line_rect);
1563 if (IntersectRect(&rc, &line_rect, &es->format_rect))
1564 EDIT_UpdateText(wnd, &rc, FALSE);
1565 }
1566
1567
1568 /*********************************************************************
1569 *
1570 * EDIT_ML_InvalidateText
1571 *
1572 * Called from EDIT_InvalidateText().
1573 * Does the job for multi-line controls only.
1574 *
1575 */
1576 static void EDIT_ML_InvalidateText(WND *wnd, EDITSTATE *es, INT start, INT end)
1577 {
1578 INT vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
1579 INT sl = EDIT_EM_LineFromChar(es, start);
1580 INT el = EDIT_EM_LineFromChar(es, end);
1581 INT sc;
1582 INT ec;
1583 RECT rc1;
1584 RECT rcWnd;
1585 RECT rcLine;
1586 RECT rcUpdate;
1587 INT l;
1588
1589 if ((el < es->y_offset) || (sl > es->y_offset + vlc))
1590 return;
1591
1592 sc = start - EDIT_EM_LineIndex(es, sl);
1593 ec = end - EDIT_EM_LineIndex(es, el);
1594 if (sl < es->y_offset) {
1595 sl = es->y_offset;
1596 sc = 0;
1597 }
1598 if (el > es->y_offset + vlc) {
1599 el = es->y_offset + vlc;
1600 ec = EDIT_EM_LineLength(es, EDIT_EM_LineIndex(es, el));
1601 }
1602 GetClientRect(wnd->hwndSelf, &rc1);
1603 IntersectRect(&rcWnd, &rc1, &es->format_rect);
1604 if (sl == el) {
1605 EDIT_GetLineRect(wnd, es, sl, sc, ec, &rcLine);
1606 if (IntersectRect(&rcUpdate, &rcWnd, &rcLine))
1607 EDIT_UpdateText(wnd, &rcUpdate, FALSE);
1608 } else {
1609 EDIT_GetLineRect(wnd, es, sl, sc,
1610 EDIT_EM_LineLength(es,
1611 EDIT_EM_LineIndex(es, sl)),
1612 &rcLine);
1613 if (IntersectRect(&rcUpdate, &rcWnd, &rcLine))
1614 EDIT_UpdateText(wnd, &rcUpdate, FALSE);
1615 for (l = sl + 1 ; l < el ; l++) {
1616 EDIT_GetLineRect(wnd, es, l, 0,
1617 EDIT_EM_LineLength(es,
1618 EDIT_EM_LineIndex(es, l)),
1619 &rcLine);
1620 if (IntersectRect(&rcUpdate, &rcWnd, &rcLine))
1621 EDIT_UpdateText(wnd, &rcUpdate, FALSE);
1622 }
1623 EDIT_GetLineRect(wnd, es, el, 0, ec, &rcLine);
1624 if (IntersectRect(&rcUpdate, &rcWnd, &rcLine))
1625 EDIT_UpdateText(wnd, &rcUpdate, FALSE);
1626 }
1627 }
1628
1629
1630 /*********************************************************************
1631 *
1632 * EDIT_InvalidateText
1633 *
1634 * Invalidate the text from offset start upto, but not including,
1635 * offset end. Useful for (re)painting the selection.
1636 * Regions outside the linewidth are not invalidated.
1637 * end == -1 means end == TextLength.
1638 * start and end need not be ordered.
1639 *
1640 */
1641 static void EDIT_InvalidateText(WND *wnd, EDITSTATE *es, INT start, INT end)
1642 {
1643 if (end == start)
1644 return;
1645
1646 if (end == -1)
1647 end = strlenW(es->text);
1648
1649 ORDER_INT(start, end);
1650
1651 if (es->style & ES_MULTILINE)
1652 EDIT_ML_InvalidateText(wnd, es, start, end);
1653 else
1654 EDIT_SL_InvalidateText(wnd, es, start, end);
1655 }
1656
1657
1658 /*********************************************************************
1659 *
1660 * EDIT_MakeFit
1661 *
1662 * Try to fit size + 1 characters in the buffer. Constrain to limits.
1663 *
1664 */
1665 static BOOL EDIT_MakeFit(WND *wnd, EDITSTATE *es, UINT size)
1666 {
1667 HLOCAL hNew32W;
1668
1669 if (size <= es->buffer_size)
1670 return TRUE;
1671 if (size > es->buffer_limit) {
1672 EDIT_NOTIFY_PARENT(wnd, EN_MAXTEXT, "EN_MAXTEXT");
1673 return FALSE;
1674 }
1675 if (size > es->buffer_limit)
1676 size = es->buffer_limit;
1677
1678 TRACE("trying to ReAlloc to %d+1 characters\n", size);
1679
1680 /* Force edit to unlock it's buffer. es->text now NULL */
1681 EDIT_UnlockBuffer(wnd, es, TRUE);
1682
1683 if (es->hloc32W) {
1684 UINT alloc_size = ROUND_TO_GROW((size + 1) * sizeof(WCHAR));
1685 if ((hNew32W = LocalReAlloc(es->hloc32W, alloc_size, LMEM_MOVEABLE | LMEM_ZEROINIT))) {
1686 TRACE("Old 32 bit handle %08x, new handle %08x\n", es->hloc32W, hNew32W);
1687 es->hloc32W = hNew32W;
1688 es->buffer_size = LocalSize(hNew32W)/sizeof(WCHAR) - 1;
1689 }
1690 }
1691
1692 EDIT_LockBuffer(wnd, es);
1693
1694 if (es->buffer_size < size) {
1695 WARN("FAILED ! We now have %d+1\n", es->buffer_size);
1696 EDIT_NOTIFY_PARENT(wnd, EN_ERRSPACE, "EN_ERRSPACE");
1697 return FALSE;
1698 } else {
1699 TRACE("We now have %d+1\n", es->buffer_size);
1700 return TRUE;
1701 }
1702 }
1703
1704
1705 /*********************************************************************
1706 *
1707 * EDIT_MakeUndoFit
1708 *
1709 * Try to fit size + 1 bytes in the undo buffer.
1710 *
1711 */
1712 static BOOL EDIT_MakeUndoFit(EDITSTATE *es, UINT size)
1713 {
1714 UINT alloc_size;
1715
1716 if (size <= es->undo_buffer_size)
1717 return TRUE;
1718
1719 TRACE("trying to ReAlloc to %d+1\n", size);
1720
1721 alloc_size = ROUND_TO_GROW((size + 1) * sizeof(WCHAR));
1722 if ((es->undo_text = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, es->undo_text, alloc_size))) {
1723 es->undo_buffer_size = alloc_size/sizeof(WCHAR);
1724 return TRUE;
1725 }
1726 else
1727 {
1728 WARN("FAILED ! We now have %d+1\n", es->undo_buffer_size);
1729 return FALSE;
1730 }
1731 }
1732
1733
1734 /*********************************************************************
1735 *
1736 * EDIT_MoveBackward
1737 *
1738 */
1739 static void EDIT_MoveBackward(WND *wnd, EDITSTATE *es, BOOL extend)
1740 {
1741 INT e = es->selection_end;
1742
1743 if (e) {
1744 e--;
1745 if ((es->style & ES_MULTILINE) && e &&
1746 (es->text[e - 1] == '\r') && (es->text[e] == '\n')) {
1747 e--;
1748 if (e && (es->text[e - 1] == '\r'))
1749 e--;
1750 }
1751 }
1752 EDIT_EM_SetSel(wnd, es, extend ? es->selection_start : e, e, FALSE);
1753 EDIT_EM_ScrollCaret(wnd, es);
1754 }
1755
1756
1757 /*********************************************************************
1758 *
1759 * EDIT_MoveDown_ML
1760 *
1761 * Only for multi line controls
1762 * Move the caret one line down, on a column with the nearest
1763 * x coordinate on the screen (might be a different column).
1764 *
1765 */
1766 static void EDIT_MoveDown_ML(WND *wnd, EDITSTATE *es, BOOL extend)
1767 {
1768 INT s = es->selection_start;
1769 INT e = es->selection_end;
1770 BOOL after_wrap = (es->flags & EF_AFTER_WRAP);
1771 LRESULT pos = EDIT_EM_PosFromChar(wnd, es, e, after_wrap);
1772 INT x = SLOWORD(pos);
1773 INT y = SHIWORD(pos);
1774
1775 e = EDIT_CharFromPos(wnd, es, x, y + es->line_height, &after_wrap);
1776 if (!extend)
1777 s = e;
1778 EDIT_EM_SetSel(wnd, es, s, e, after_wrap);
1779 EDIT_EM_ScrollCaret(wnd, es);
1780 }
1781
1782
1783 /*********************************************************************
1784 *
1785 * EDIT_MoveEnd
1786 *
1787 */
1788 static void EDIT_MoveEnd(WND *wnd, EDITSTATE *es, BOOL extend)
1789 {
1790 BOOL after_wrap = FALSE;
1791 INT e;
1792
1793 /* Pass a high value in x to make sure of receiving the end of the line */
1794 if (es->style & ES_MULTILINE)
1795 e = EDIT_CharFromPos(wnd, es, 0x3fffffff,
1796 HIWORD(EDIT_EM_PosFromChar(wnd, es, es->selection_end, es->flags & EF_AFTER_WRAP)), &after_wrap);
1797 else
1798 e = strlenW(es->text);
1799 EDIT_EM_SetSel(wnd, es, extend ? es->selection_start : e, e, after_wrap);
1800 EDIT_EM_ScrollCaret(wnd, es);
1801 }
1802
1803
1804 /*********************************************************************
1805 *
1806 * EDIT_MoveForward
1807 *
1808 */
1809 static void EDIT_MoveForward(WND *wnd, EDITSTATE *es, BOOL extend)
1810 {
1811 INT e = es->selection_end;
1812
1813 if (es->text[e]) {
1814 e++;
1815 if ((es->style & ES_MULTILINE) && (es->text[e - 1] == '\r')) {
1816 if (es->text[e] == '\n')
1817 e++;
1818 else if ((es->text[e] == '\r') && (es->text[e + 1] == '\n'))
1819 e += 2;
1820 }
1821 }
1822 EDIT_EM_SetSel(wnd, es, extend ? es->selection_start : e, e, FALSE);
1823 EDIT_EM_ScrollCaret(wnd, es);
1824 }
1825
1826
1827 /*********************************************************************
1828 *
1829 * EDIT_MoveHome
1830 *
1831 * Home key: move to beginning of line.
1832 *
1833 */
1834 static void EDIT_MoveHome(WND *wnd, EDITSTATE *es, BOOL extend)
1835 {
1836 INT e;
1837
1838 /* Pass the x_offset in x to make sure of receiving the first position of the line */
1839 if (es->style & ES_MULTILINE)
1840 e = EDIT_CharFromPos(wnd, es, -es->x_offset,
1841 HIWORD(EDIT_EM_PosFromChar(wnd, es, es->selection_end, es->flags & EF_AFTER_WRAP)), NULL);
1842 else
1843 e = 0;
1844 EDIT_EM_SetSel(wnd, es, extend ? es->selection_start : e, e, FALSE);
1845 EDIT_EM_ScrollCaret(wnd, es);
1846 }
1847
1848
1849 /*********************************************************************
1850 *
1851 * EDIT_MovePageDown_ML
1852 *
1853 * Only for multi line controls
1854 * Move the caret one page down, on a column with the nearest
1855 * x coordinate on the screen (might be a different column).
1856 *
1857 */
1858 static void EDIT_MovePageDown_ML(WND *wnd, EDITSTATE *es, BOOL extend)
1859 {
1860 INT s = es->selection_start;
1861 INT e = es->selection_end;
1862 BOOL after_wrap = (es->flags & EF_AFTER_WRAP);
1863 LRESULT pos = EDIT_EM_PosFromChar(wnd, es, e, after_wrap);
1864 INT x = SLOWORD(pos);
1865 INT y = SHIWORD(pos);
1866
1867 e = EDIT_CharFromPos(wnd, es, x,
1868 y + (es->format_rect.bottom - es->format_rect.top),
1869 &after_wrap);
1870 if (!extend)
1871 s = e;
1872 EDIT_EM_SetSel(wnd, es, s, e, after_wrap);
1873 EDIT_EM_ScrollCaret(wnd, es);
1874 }
1875
1876
1877 /*********************************************************************
1878 *
1879 * EDIT_MovePageUp_ML
1880 *
1881 * Only for multi line controls
1882 * Move the caret one page up, on a column with the nearest
1883 * x coordinate on the screen (might be a different column).
1884 *
1885 */
1886 static void EDIT_MovePageUp_ML(WND *wnd, EDITSTATE *es, BOOL extend)
1887 {
1888 INT s = es->selection_start;
1889 INT e = es->selection_end;
1890 BOOL after_wrap = (es->flags & EF_AFTER_WRAP);
1891 LRESULT pos = EDIT_EM_PosFromChar(wnd, es, e, after_wrap);
1892 INT x = SLOWORD(pos);
1893 INT y = SHIWORD(pos);
1894
1895 e = EDIT_CharFromPos(wnd, es, x,
1896 y - (es->format_rect.bottom - es->format_rect.top),
1897 &after_wrap);
1898 if (!extend)
1899 s = e;
1900 EDIT_EM_SetSel(wnd, es, s, e, after_wrap);
1901 EDIT_EM_ScrollCaret(wnd, es);
1902 }
1903
1904
1905 /*********************************************************************
1906 *
1907 * EDIT_MoveUp_ML
1908 *
1909 * Only for multi line controls
1910 * Move the caret one line up, on a column with the nearest
1911 * x coordinate on the screen (might be a different column).
1912 *
1913 */
1914 static void EDIT_MoveUp_ML(WND *wnd, EDITSTATE *es, BOOL extend)
1915 {
1916 INT s = es->selection_start;
1917 INT e = es->selection_end;
1918 BOOL after_wrap = (es->flags & EF_AFTER_WRAP);
1919 LRESULT pos = EDIT_EM_PosFromChar(wnd, es, e, after_wrap);
1920 INT x = SLOWORD(pos);
1921 INT y = SHIWORD(pos);
1922
1923 e = EDIT_CharFromPos(wnd, es, x, y - es->line_height, &after_wrap);
1924 if (!extend)
1925 s = e;
1926 EDIT_EM_SetSel(wnd, es, s, e, after_wrap);
1927 EDIT_EM_ScrollCaret(wnd, es);
1928 }
1929
1930
1931 /*********************************************************************
1932 *
1933 * EDIT_MoveWordBackward
1934 *
1935 */
1936 static void EDIT_MoveWordBackward(WND *wnd, EDITSTATE *es, BOOL extend)
1937 {
1938 INT s = es->selection_start;
1939 INT e = es->selection_end;
1940 INT l;
1941 INT ll;
1942 INT li;
1943
1944 l = EDIT_EM_LineFromChar(es, e);
1945 ll = EDIT_EM_LineLength(es, e);
1946 li = EDIT_EM_LineIndex(es, l);
1947 if (e - li == 0) {
1948 if (l) {
1949 li = EDIT_EM_LineIndex(es, l - 1);
1950 e = li + EDIT_EM_LineLength(es, li);
1951 }
1952 } else {
1953 e = li + (INT)EDIT_CallWordBreakProc(es,
1954 li, e - li, ll, WB_LEFT);
1955 }
1956 if (!extend)
1957 s = e;
1958 EDIT_EM_SetSel(wnd, es, s, e, FALSE);
1959 EDIT_EM_ScrollCaret(wnd, es);
1960 }
1961
1962
1963 /*********************************************************************
1964 *
1965 * EDIT_MoveWordForward
1966 *
1967 */
1968 static void EDIT_MoveWordForward(WND *wnd, EDITSTATE *es, BOOL extend)
1969 {
1970 INT s = es->selection_start;
1971 INT e = es->selection_end;
1972 INT l;
1973 INT ll;
1974 INT li;
1975
1976 l = EDIT_EM_LineFromChar(es, e);
1977 ll = EDIT_EM_LineLength(es, e);
1978 li = EDIT_EM_LineIndex(es, l);
1979 if (e - li == ll) {
1980 if ((es->style & ES_MULTILINE) && (l != es->line_count - 1))
1981 e = EDIT_EM_LineIndex(es, l + 1);
1982 } else {
1983 e = li + EDIT_CallWordBreakProc(es,
1984 li, e - li + 1, ll, WB_RIGHT);
1985 }
1986 if (!extend)
1987 s = e;
1988 EDIT_EM_SetSel(wnd, es, s, e, FALSE);
1989 EDIT_EM_ScrollCaret(wnd, es);
1990 }
1991
1992
1993 /*********************************************************************
1994 *
1995 * EDIT_PaintLine
1996 *
1997 */
1998 static void EDIT_PaintLine(WND *wnd, EDITSTATE *es, HDC dc, INT line, BOOL rev)
1999 {
2000 INT s = es->selection_start;
2001 INT e = es->selection_end;
2002 INT li;
2003 INT ll;
2004 INT x;
2005 INT y;
2006 LRESULT pos;
2007
2008 if (es->style & ES_MULTILINE) {
2009 INT vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
2010 if ((line < es->y_offset) || (line > es->y_offset + vlc) || (line >= es->line_count))
2011 return;
2012 } else if (line)
2013 return;
2014
2015 TRACE("line=%d\n", line);
2016
2017 pos = EDIT_EM_PosFromChar(wnd, es, EDIT_EM_LineIndex(es, line), FALSE);
2018 x = SLOWORD(pos);
2019 y = SHIWORD(pos);
2020 li = EDIT_EM_LineIndex(es, line);
2021 ll = EDIT_EM_LineLength(es, li);
2022 s = es->selection_start;
2023 e = es->selection_end;
2024 ORDER_INT(s, e);
2025 s = min(li + ll, max(li, s));
2026 e = min(li + ll, max(li, e));
2027 if (rev && (s != e) &&
2028 ((es->flags & EF_FOCUSED) || (es->style & ES_NOHIDESEL))) {
2029 x += EDIT_PaintText(es, dc, x, y, line, 0, s - li, FALSE);
2030 x += EDIT_PaintText(es, dc, x, y, line, s - li, e - s, TRUE);
2031 x += EDIT_PaintText(es, dc, x, y, line, e - li, li + ll - e, FALSE);
2032 } else
2033 x += EDIT_PaintText(es, dc, x, y, line, 0, ll, FALSE);
2034 }
2035
2036
2037 /*********************************************************************
2038 *
2039 * EDIT_PaintText
2040 *
2041 */
2042 static INT EDIT_PaintText(EDITSTATE *es, HDC dc, INT x, INT y, INT line, INT col, INT count, BOOL rev)
2043 {
2044 COLORREF BkColor;
2045 COLORREF TextColor;
2046 INT ret;
2047 INT li;
2048 SIZE size;
2049
2050 if (!count)
2051 return 0;
2052 BkColor = GetBkColor(dc);
2053 TextColor = GetTextColor(dc);
2054 if (rev) {
2055 SetBkColor(dc, GetSysColor(COLOR_HIGHLIGHT));
2056 SetTextColor(dc, GetSysColor(COLOR_HIGHLIGHTTEXT));
2057 }
2058 li = EDIT_EM_LineIndex(es, line);
2059 if (es->style & ES_MULTILINE) {
2060 ret = (INT)LOWORD(TabbedTextOutW(dc, x, y, es->text + li + col, count,
2061 es->tabs_count, es->tabs, es->format_rect.left - es->x_offset));
2062 } else {
2063 LPWSTR text = EDIT_GetPasswordPointer_SL(es);
2064 TextOutW(dc, x, y, text + li + col, count);
2065 GetTextExtentPoint32W(dc, text + li + col, count, &size);
2066 ret = size.cx;
2067 if (es->style & ES_PASSWORD)
2068 HeapFree(GetProcessHeap(), 0, text);
2069 }
2070 if (rev) {
2071 SetBkColor(dc, BkColor);
2072 SetTextColor(dc, TextColor);
2073 }
2074 return ret;
2075 }
2076
2077
2078 /*********************************************************************
2079 *
2080 * EDIT_SetCaretPos
2081 *
2082 */
2083 static void EDIT_SetCaretPos(WND *wnd, EDITSTATE *es, INT pos,
2084 BOOL after_wrap)
2085 {
2086 LRESULT res = EDIT_EM_PosFromChar(wnd, es, pos, after_wrap);
2087 SetCaretPos(SLOWORD(res), SHIWORD(res));
2088 }
2089
2090
2091 /*********************************************************************
2092 *
2093 * EDIT_SetRectNP
2094 *
2095 * note: this is not (exactly) the handler called on EM_SETRECTNP
2096 * it is also used to set the rect of a single line control
2097 *
2098 */
2099 static void EDIT_SetRectNP(WND *wnd, EDITSTATE *es, LPRECT rc)
2100 {
2101 CopyRect(&es->format_rect, rc);
2102 if (es->style & WS_BORDER) {
2103 INT bw = GetSystemMetrics(SM_CXBORDER) + 1;
2104 if(TWEAK_WineLook == WIN31_LOOK)
2105 bw += 2;
2106 es->format_rect.left += bw;
2107 es->format_rect.top += bw;
2108 es->format_rect.right -= bw;
2109 es->format_rect.bottom -= bw;
2110 }
2111 es->format_rect.left += es->left_margin;
2112 es->format_rect.right -= es->right_margin;
2113 es->format_rect.right = max(es->format_rect.right, es->format_rect.left + es->char_width);
2114 if (es->style & ES_MULTILINE)
2115 {
2116 INT fw, vlc, max_x_offset, max_y_offset;
2117
2118 vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
2119 es->format_rect.bottom = es->format_rect.top + max(1, vlc) * es->line_height;
2120
2121 /* correct es->x_offset */
2122 fw = es->format_rect.right - es->format_rect.left;
2123 max_x_offset = es->text_width - fw;
2124 if(max_x_offset < 0) max_x_offset = 0;
2125 if(es->x_offset > max_x_offset)
2126 es->x_offset = max_x_offset;
2127
2128 /* correct es->y_offset */
2129 max_y_offset = es->line_count - vlc;
2130 if(max_y_offset < 0) max_y_offset = 0;
2131 if(es->y_offset > max_y_offset)
2132 es->y_offset = max_y_offset;
2133
2134 /* force scroll info update */
2135 EDIT_UpdateScrollInfo(wnd, es);
2136 }
2137 else
2138 /* Windows doesn't care to fix text placement for SL controls */
2139 es->format_rect.bottom = es->format_rect.top + es->line_height;
2140
2141 if ((es->style & ES_MULTILINE) && !(es->style & ES_AUTOHSCROLL))
2142 EDIT_BuildLineDefs_ML(wnd, es);
2143 }
2144
2145
2146 /*********************************************************************
2147 *
2148 * EDIT_UnlockBuffer
2149 *
2150 */
2151 static void EDIT_UnlockBuffer(WND *wnd, EDITSTATE *es, BOOL force)
2152 {
2153 if (!es) {
2154 ERR("no EDITSTATE ... please report\n");
2155 return;
2156 }
2157 if (!es->lock_count) {
2158 ERR("lock_count == 0 ... please report\n");
2159 return;
2160 }
2161 if (!es->text) {
2162 ERR("es->text == 0 ... please report\n");
2163 return;
2164 }
2165
2166 if (force || (es->lock_count == 1)) {
2167 if (es->hloc32W) {
2168 CHAR *textA = NULL;
2169 BOOL _16bit = FALSE;
2170 UINT countA = 0;
2171 UINT countW = strlenW(es->text) + 1;
2172
2173 if(es->hloc32A)
2174 {
2175 UINT countA_new = WideCharToMultiByte(CP_ACP, 0, es->text, countW, NULL, 0, NULL, NULL);
2176 TRACE("Synchronizing with 32-bit ANSI buffer\n");
2177 TRACE("%d WCHARs translated to %d bytes\n", countW, countA_new);
2178 countA = LocalSize(es->hloc32A);
2179 if(countA_new > countA)
2180 {
2181 HLOCAL hloc32A_new;
2182 UINT alloc_size = ROUND_TO_GROW(countA_new);
2183 TRACE("Resizing 32-bit ANSI buffer from %d to %d bytes\n", countA, alloc_size);
2184 hloc32A_new = LocalReAlloc(es->hloc32A, alloc_size, LMEM_MOVEABLE | LMEM_ZEROINIT);
2185 if(hloc32A_new)
2186 {
2187 es->hloc32A = hloc32A_new;
2188 countA = LocalSize(hloc32A_new);
2189 TRACE("Real new size %d bytes\n", countA);
2190 }
2191 else
2192 WARN("FAILED! Will synchronize partially\n");
2193 }
2194 textA = LocalLock(es->hloc32A);
2195 }
2196 else if(es->hloc16)
2197 {
2198 UINT countA_new = WideCharToMultiByte(CP_ACP, 0, es->text, countW, NULL, 0, NULL, NULL);
2199 TRACE("Synchronizing with 16-bit ANSI buffer\n");
2200 TRACE("%d WCHARs translated to %d bytes\n", countW, countA_new);
2201 countA = LOCAL_Size(wnd->hInstance, es->hloc16);
2202 if(countA_new > countA)
2203 {
2204 HLOCAL16 hloc16_new;
2205 UINT alloc_size = ROUND_TO_GROW(countA_new);
2206 TRACE("Resizing 16-bit ANSI buffer from %d to %d bytes\n", countA, alloc_size);
2207 hloc16_new = LOCAL_ReAlloc(wnd->hInstance, es->hloc16, alloc_size, LMEM_MOVEABLE | LMEM_ZEROINIT);
2208 if(hloc16_new)
2209 {
2210 es->hloc16 = hloc16_new;
2211 countA = LOCAL_Size(wnd->hInstance, hloc16_new);
2212 TRACE("Real new size %d bytes\n", countA);
2213 }
2214 else
2215 WARN("FAILED! Will synchronize partially\n");
2216 }
2217 textA = LOCAL_Lock(wnd->hInstance, es->hloc16);
2218 _16bit = TRUE;
2219 }
2220
2221 if(textA)
2222 {
2223 WideCharToMultiByte(CP_ACP, 0, es->text, countW, textA, countA, NULL, NULL);
2224 if(_16bit)
2225 LOCAL_Unlock(wnd->hInstance, es->hloc16);
2226 else
2227 LocalUnlock(es->hloc32A);
2228 }
2229
2230 LocalUnlock(es->hloc32W);
2231 es->text = NULL;
2232 }
2233 else {
2234 ERR("no buffer ... please report\n");
2235 return;
2236 }
2237 }
2238 es->lock_count--;
2239 }
2240
2241
2242 /*********************************************************************
2243 *
2244 * EDIT_UpdateScrollInfo
2245 *
2246 */
2247 static void EDIT_UpdateScrollInfo(WND *wnd, EDITSTATE *es)
2248 {
2249 if ((es->style & WS_VSCROLL) && !(es->flags & EF_VSCROLL_TRACK))
2250 {
2251 SCROLLINFO si;
2252 si.cbSize = sizeof(SCROLLINFO);
2253 si.fMask = SIF_PAGE | SIF_POS | SIF_RANGE | SIF_DISABLENOSCROLL;
2254 si.nMin = 0;
2255 si.nMax = es->line_count - 1;
2256 si.nPage = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
2257 si.nPos = es->y_offset;
2258 TRACE("SB_VERT, nMin=%d, nMax=%d, nPage=%d, nPos=%d\n",
2259 si.nMin, si.nMax, si.nPage, si.nPos);
2260 SetScrollInfo(wnd->hwndSelf, SB_VERT, &si, TRUE);
2261 }
2262
2263 if ((es->style & WS_HSCROLL) && !(es->flags & EF_HSCROLL_TRACK))
2264 {
2265 SCROLLINFO si;
2266 si.cbSize = sizeof(SCROLLINFO);
2267 si.fMask = SIF_PAGE | SIF_POS | SIF_RANGE | SIF_DISABLENOSCROLL;
2268 si.nMin = 0;
2269 si.nMax = es->text_width - 1;
2270 si.nPage = es->format_rect.right - es->format_rect.left;
2271 si.nPos = es->x_offset;
2272 TRACE("SB_HORZ, nMin=%d, nMax=%d, nPage=%d, nPos=%d\n",
2273 si.nMin, si.nMax, si.nPage, si.nPos);
2274 SetScrollInfo(wnd->hwndSelf, SB_HORZ, &si, TRUE);
2275 }
2276 }
2277
2278 /*********************************************************************
2279 *
2280 * EDIT_WordBreakProc
2281 *
2282 * Find the beginning of words.
2283 * Note: unlike the specs for a WordBreakProc, this function only
2284 * allows to be called without linebreaks between s[0] upto
2285 * s[count - 1]. Remember it is only called
2286 * internally, so we can decide this for ourselves.
2287 *
2288 */
2289 static INT CALLBACK EDIT_WordBreakProc(LPWSTR s, INT index, INT count, INT action)
2290 {
2291 INT ret = 0;
2292
2293 TRACE("s=%p, index=%d, count=%d, action=%d\n", s, index, count, action);
2294
2295 if(!s) return 0;
2296
2297 switch (action) {
2298 case WB_LEFT:
2299 if (!count)
2300 break;
2301 if (index)
2302 index--;
2303 if (s[index] == ' ') {
2304 while (index && (s[index] == ' '))
2305 index--;
2306 if (index) {
2307 while (index && (s[index] != ' '))
2308 index--;
2309 if (s[index] == ' ')
2310 index++;
2311 }
2312 } else {
2313 while (index && (s[index] != ' '))
2314 index--;
2315 if (s[index] == ' ')
2316 index++;
2317 }
2318 ret = index;
2319 break;
2320 case WB_RIGHT:
2321 if (!count)
2322 break;
2323 if (index)
2324 index--;
2325 if (s[index] == ' ')
2326 while ((index < count) && (s[index] == ' ')) index++;
2327 else {
2328 while (s[index] && (s[index] != ' ') && (index < count))
2329 index++;
2330 while ((s[index] == ' ') && (index < count)) index++;
2331 }
2332 ret = index;
2333 break;
2334 case WB_ISDELIMITER:
2335 ret = (s[index] == ' ');
2336 break;
2337 default:
2338 ERR("unknown action code, please report !\n");
2339 break;
2340 }
2341 return ret;
2342 }
2343
2344
2345 /*********************************************************************
2346 *
2347 * EM_CHARFROMPOS
2348 *
2349 * returns line number (not index) in high-order word of result.
2350 * NB : Q137805 is unclear about this. POINT * pointer in lParam apply
2351 * to Richedit, not to the edit control. Original documentation is valid.
2352 * FIXME: do the specs mean to return -1 if outside client area or
2353 * if outside formatting rectangle ???
2354 *
2355 */
2356 static LRESULT EDIT_EM_CharFromPos(WND *wnd, EDITSTATE *es, INT x, INT y)
2357 {
2358 POINT pt;
2359 RECT rc;
2360 INT index;
2361
2362 pt.x = x;
2363 pt.y = y;
2364 GetClientRect(wnd->hwndSelf, &rc);
2365 if (!PtInRect(&rc, pt))
2366 return -1;
2367
2368 index = EDIT_CharFromPos(wnd, es, x, y, NULL);
2369 return MAKELONG(index, EDIT_EM_LineFromChar(es, index));
2370 }
2371
2372
2373 /*********************************************************************
2374 *
2375 * EM_FMTLINES
2376 *
2377 * Enable or disable soft breaks.
2378 */
2379 static BOOL EDIT_EM_FmtLines(EDITSTATE *es, BOOL add_eol)
2380 {
2381 es->flags &= ~EF_USE_SOFTBRK;
2382 if (add_eol) {
2383 es->flags |= EF_USE_SOFTBRK;
2384 FIXME("soft break enabled, not implemented\n");
2385 }
2386 return add_eol;
2387 }
2388
2389
2390 /*********************************************************************
2391 *
2392 * EM_GETHANDLE
2393 *
2394 * Hopefully this won't fire back at us.
2395 * We always start with a fixed buffer in the local heap.
2396 * Despite of the documentation says that the local heap is used
2397 * only if DS_LOCALEDIT flag is set, NT and 2000 always allocate
2398 * buffer on the local heap.
2399 *
2400 */
2401 static HLOCAL EDIT_EM_GetHandle(EDITSTATE *es)
2402 {
2403 HLOCAL hLocal;
2404
2405 if (!(es->style & ES_MULTILINE))
2406 return 0;
2407
2408 if(es->is_unicode)
2409 hLocal = es->hloc32W;
2410 else
2411 {
2412 if(!es->hloc32A)
2413 {
2414 CHAR *textA;
2415 UINT countA, alloc_size;
2416 TRACE("Allocating 32-bit ANSI alias buffer\n");
2417 countA = WideCharToMultiByte(CP_ACP, 0, es->text, -1, NULL, 0, NULL, NULL);
2418 alloc_size = ROUND_TO_GROW(countA);
2419 if(!(es->hloc32A = LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT, alloc_size)))
2420 {
2421 ERR("Could not allocate %d bytes for 32-bit ANSI alias buffer\n", alloc_size);
2422 return 0;
2423 }
2424 textA = LocalLock(es->hloc32A);
2425 WideCharToMultiByte(CP_ACP, 0, es->text, -1, textA, countA, NULL, NULL);
2426 LocalUnlock(es->hloc32A);
2427 }
2428 hLocal = es->hloc32A;
2429 }
2430
2431 TRACE("Returning %04X, LocalSize() = %d\n", hLocal, LocalSize(hLocal));
2432 return hLocal;
2433 }
2434
2435
2436 /*********************************************************************
2437 *
2438 * EM_GETHANDLE16
2439 *
2440 * Hopefully this won't fire back at us.
2441 * We always start with a buffer in 32 bit linear memory.
2442 * However, with this message a 16 bit application requests
2443 * a handle of 16 bit local heap memory, where it expects to find
2444 * the text.
2445 * It's a pitty that from this moment on we have to use this
2446 * local heap, because applications may rely on the handle
2447 * in the future.
2448 *
2449 * In this function we'll try to switch to local heap.
2450 */
2451 static HLOCAL16 EDIT_EM_GetHandle16(WND *wnd, EDITSTATE *es)
2452 {
2453 CHAR *textA;
2454 UINT countA, alloc_size;
2455
2456 if (!(es->style & ES_MULTILINE))
2457 return 0;
2458
2459 if (es->hloc16)
2460 return es->hloc16;
2461
2462 if (!LOCAL_HeapSize(wnd->hInstance)) {
2463 if (!LocalInit16(wnd->hInstance, 0,
2464 GlobalSize16(wnd->hInstance))) {
2465 ERR("could not initialize local heap\n");
2466 return 0;
2467 }
2468 TRACE("local heap initialized\n");
2469 }
2470
2471 countA = WideCharToMultiByte(CP_ACP, 0, es->text, -1, NULL, 0, NULL, NULL);
2472 alloc_size = ROUND_TO_GROW(countA);
2473
2474 TRACE("Allocating 16-bit ANSI alias buffer\n");
2475 if (!(es->hloc16 = LOCAL_Alloc(wnd->hInstance, LMEM_MOVEABLE | LMEM_ZEROINIT, alloc_size))) {
2476 ERR("could not allocate new 16 bit buffer\n");
2477 return 0;
2478 }
2479
2480 if (!(textA = (LPSTR)LOCAL_Lock(wnd->hInstance, es->hloc16))) {
2481 ERR("could not lock new 16 bit buffer\n");
2482 LOCAL_Free(wnd->hInstance, es->hloc16);
2483 es->hloc16 = 0;
2484 return 0;
2485 }
2486
2487 WideCharToMultiByte(CP_ACP, 0, es->text, -1, textA, countA, NULL, NULL);
2488 LOCAL_Unlock(wnd->hInstance, es->hloc16);
2489
2490 TRACE("Returning %04X, LocalSize() = %d\n", es->hloc16, LOCAL_Size(wnd->hInstance, es->hloc16));
2491 return es->hloc16;
2492 }
2493
2494
2495 /*********************************************************************
2496 *
2497 * EM_GETLINE
2498 *
2499 */
2500 static INT EDIT_EM_GetLine(EDITSTATE *es, INT line, LPWSTR lpch)
2501 {
2502 LPWSTR src;
2503 INT len;
2504 INT i;
2505
2506 if (es->style & ES_MULTILINE) {
2507 if (line >= es->line_count)
2508 return 0;
2509 } else
2510 line = 0;
2511 i = EDIT_EM_LineIndex(es, line);
2512 src = es->text + i;
2513 len = min(*(WORD *)lpch, EDIT_EM_LineLength(es, i));
2514 for (i = 0 ; i < len ; i++) {
2515 *lpch = *src;
2516 src++;
2517 lpch++;
2518 }
2519 return (LRESULT)len;
2520 }
2521
2522
2523 /*********************************************************************
2524 *
2525 * EM_GETSEL
2526 *
2527 */
2528 static LRESULT EDIT_EM_GetSel(EDITSTATE *es, LPUINT start, LPUINT end)
2529 {
2530 UINT s = es->selection_start;
2531 UINT e = es->selection_end;
2532
2533 ORDER_UINT(s, e);
2534 if (start)
2535 *start = s;
2536 if (end)
2537 *end = e;
2538 return MAKELONG(s, e);
2539 }
2540
2541
2542 /*********************************************************************
2543 *
2544 * EM_GETTHUMB
2545 *
2546 * FIXME: is this right ? (or should it be only VSCROLL)
2547 * (and maybe only for edit controls that really have their
2548 * own scrollbars) (and maybe only for multiline controls ?)
2549 * All in all: very poorly documented
2550 *
2551 */
2552 static LRESULT EDIT_EM_GetThumb(WND *wnd, EDITSTATE *es)
2553 {
2554 return MAKELONG(EDIT_WM_VScroll(wnd, es, EM_GETTHUMB16, 0),
2555 EDIT_WM_HScroll(wnd, es, EM_GETTHUMB16, 0));
2556 }
2557
2558
2559 /*********************************************************************
2560 *
2561 * EM_LINEFROMCHAR
2562 *
2563 */
2564 static INT EDIT_EM_LineFromChar(EDITSTATE *es, INT index)
2565 {
2566 INT line;
2567 LINEDEF *line_def;
2568
2569 if (!(es->style & ES_MULTILINE))
2570 return 0;
2571 if (index > (INT)strlenW(es->text))
2572 return es->line_count - 1;
2573 if (index == -1)
2574 index = min(es->selection_start, es->selection_end);
2575
2576 line = 0;
2577 line_def = es->first_line_def;
2578 index -= line_def->length;
2579 while ((index >= 0) && line_def->next) {
2580 line++;
2581 line_def = line_def->next;
2582 index -= line_def->length;
2583 }
2584 return line;
2585 }
2586
2587
2588 /*********************************************************************
2589 *
2590 * EM_LINEINDEX
2591 *
2592 */
2593 static INT EDIT_EM_LineIndex(EDITSTATE *es, INT line)
2594 {
2595 INT line_index;
2596 LINEDEF *line_def;
2597
2598 if (!(es->style & ES_MULTILINE))
2599 return 0;
2600 if (line >= es->line_count)
2601 return -1;
2602
2603 line_index = 0;
2604 line_def = es->first_line_def;
2605 if (line == -1) {
2606 INT index = es->selection_end - line_def->length;
2607 while ((index >= 0) && line_def->next) {
2608 line_index += line_def->length;
2609 line_def = line_def->next;
2610 index -= line_def->length;
2611 }
2612 } else {
2613 while (line > 0) {
2614 line_index += line_def->length;
2615 line_def = line_def->next;
2616 line--;
2617 }
2618 }
2619 return line_index;
2620 }
2621
2622
2623 /*********************************************************************
2624 *
2625 * EM_LINELENGTH
2626 *
2627 */
2628 static INT EDIT_EM_LineLength(EDITSTATE *es, INT index)
2629 {
2630 LINEDEF *line_def;
2631
2632 if (!(es->style & ES_MULTILINE))
2633 return strlenW(es->text);
2634
2635 if (index == -1) {
2636 /* get the number of remaining non-selected chars of selected lines */
2637 INT32 li;
2638 INT32 count;
2639 li = EDIT_EM_LineFromChar(es, es->selection_start);
2640 /* # chars before start of selection area */
2641 count = es->selection_start - EDIT_EM_LineIndex(es, li);
2642 li = EDIT_EM_LineFromChar(es, es->selection_end);
2643 /* # chars after end of selection */
2644 count += EDIT_EM_LineIndex(es, li) +
2645 EDIT_EM_LineLength(es, li) - es->selection_end;
2646 return count;
2647 }
2648 line_def = es->first_line_def;
2649 index -= line_def->length;
2650 while ((index >= 0) && line_def->next) {
2651 line_def = line_def->next;
2652 index -= line_def->length;
2653 }
2654 return line_def->net_length;
2655 }
2656
2657
2658 /*********************************************************************
2659 *
2660 * EM_LINESCROLL
2661 *
2662 * NOTE: dx is in average character widths, dy - in lines;
2663 *
2664 */
2665 static BOOL EDIT_EM_LineScroll(WND *wnd, EDITSTATE *es, INT dx, INT dy)
2666 {
2667 if (!(es->style & ES_MULTILINE))
2668 return FALSE;
2669
2670 dx *= es->char_width;
2671 return EDIT_EM_LineScroll_internal(wnd, es, dx, dy);
2672 }
2673
2674 /*********************************************************************
2675 *
2676 * EDIT_EM_LineScroll_internal
2677 *
2678 * Version of EDIT_EM_LineScroll for internal use.
2679 * It doesn't refuse if ES_MULTILINE is set and assumes that
2680 * dx is in pixels, dy - in lines.
2681 *
2682 */
2683 static BOOL EDIT_EM_LineScroll_internal(WND *wnd, EDITSTATE *es, INT dx, INT dy)
2684 {
2685 INT nyoff;
2686 INT x_offset_in_pixels;
2687
2688 if (es->style & ES_MULTILINE)
2689 {
2690 x_offset_in_pixels = es->x_offset;
2691 }
2692 else
2693 {
2694 dy = 0;
2695 x_offset_in_pixels = SLOWORD(EDIT_EM_PosFromChar(wnd, es, es->x_offset, FALSE));
2696 }
2697
2698 if (-dx > x_offset_in_pixels)
2699 dx = -x_offset_in_pixels;
2700 if (dx > es->text_width - x_offset_in_pixels)
2701 dx = es->text_width - x_offset_in_pixels;
2702 nyoff = max(0, es->y_offset + dy);
2703 if (nyoff >= es->line_count)
2704 nyoff = es->line_count - 1;
2705 dy = (es->y_offset - nyoff) * es->line_height;
2706 if (dx || dy) {
2707 RECT rc1;
2708 RECT rc;
2709
2710 es->y_offset = nyoff;
2711 if(es->style & ES_MULTILINE)
2712 es->x_offset += dx;
2713 else
2714 es->x_offset += dx / es->char_width;
2715
2716 GetClientRect(wnd->hwndSelf, &rc1);
2717 IntersectRect(&rc, &rc1, &es->format_rect);
2718 ScrollWindowEx(wnd->hwndSelf, -dx, dy,
2719 NULL, &rc, (HRGN)NULL, NULL, SW_INVALIDATE);
2720 /* force scroll info update */
2721 EDIT_UpdateScrollInfo(wnd, es);
2722 }
2723 if (dx && !(es->flags & EF_HSCROLL_TRACK))
2724 EDIT_NOTIFY_PARENT(wnd, EN_HSCROLL, "EN_HSCROLL");
2725 if (dy && !(es->flags & EF_VSCROLL_TRACK))
2726 EDIT_NOTIFY_PARENT(wnd, EN_VSCROLL, "EN_VSCROLL");
2727 return TRUE;
2728 }
2729
2730
2731 /*********************************************************************
2732 *
2733 * EM_POSFROMCHAR
2734 *
2735 */
2736 static LRESULT EDIT_EM_PosFromChar(WND *wnd, EDITSTATE *es, INT index, BOOL after_wrap)
2737 {
2738 INT len = strlenW(es->text);
2739 INT l;
2740 INT li;
2741 INT x;
2742 INT y = 0;
2743 HDC dc;
2744 HFONT old_font = 0;
2745 SIZE size;
2746
2747 index = min(index, len);
2748 dc = GetDC(wnd->hwndSelf);
2749 if (es->font)
2750 old_font = SelectObject(dc, es->font);
2751 if (es->style & ES_MULTILINE) {
2752 l = EDIT_EM_LineFromChar(es, index);
2753 y = (l - es->y_offset) * es->line_height;
2754 li = EDIT_EM_LineIndex(es, l);
2755 if (after_wrap && (li == index) && l) {
2756 INT l2 = l - 1;
2757 LINEDEF *line_def = es->first_line_def;
2758 while (l2) {
2759 line_def = line_def->next;
2760 l2--;
2761 }
2762 if (line_def->ending == END_WRAP) {
2763 l--;
2764 y -= es->line_height;
2765 li = EDIT_EM_LineIndex(es, l);
2766 }
2767 }
2768 x = LOWORD(GetTabbedTextExtentW(dc, es->text + li, index - li,
2769 es->tabs_count, es->tabs)) - es->x_offset;
2770 } else {
2771 LPWSTR text = EDIT_GetPasswordPointer_SL(es);
2772 if (index < es->x_offset) {
2773 GetTextExtentPoint32W(dc, text + index,
2774 es->x_offset - index, &size);
2775 x = -size.cx;
2776 } else {
2777 GetTextExtentPoint32W(dc, text + es->x_offset,
2778 index - es->x_offset, &size);
2779 x = size.cx;
2780 }
2781 y = 0;
2782 if (es->style & ES_PASSWORD)
2783 HeapFree(GetProcessHeap(), 0, text);
2784 }
2785 x += es->format_rect.left;
2786 y += es->format_rect.top;
2787 if (es->font)
2788 SelectObject(dc, old_font);
2789 ReleaseDC(wnd->hwndSelf, dc);
2790 return MAKELONG((INT16)x, (INT16)y);
2791 }
2792
2793
2794 /*********************************************************************
2795 *
2796 * EM_REPLACESEL
2797 *
2798 * FIXME: handle ES_NUMBER and ES_OEMCONVERT here
2799 *
2800 */
2801 static void EDIT_EM_ReplaceSel(WND *wnd, EDITSTATE *es, BOOL can_undo, LPCWSTR lpsz_replace, BOOL send_update)
2802 {
2803 UINT strl = strlenW(lpsz_replace);
2804 UINT tl = strlenW(es->text);
2805 UINT utl;
2806 UINT s;
2807 UINT e;
2808 UINT i;
2809 LPWSTR p;
2810
2811 TRACE("%s, can_undo %d, send_update %d\n",
2812 debugstr_w(lpsz_replace), can_undo, send_update);
2813
2814 s = es->selection_start;
2815 e = es->selection_end;
2816
2817 if ((s == e) && !strl)
2818 return;
2819
2820 ORDER_UINT(s, e);
2821
2822 if (!EDIT_MakeFit(wnd, es, tl - (e - s) + strl))
2823 return;
2824
2825 if (e != s) {
2826 /* there is something to be deleted */
2827 if (can_undo) {
2828 utl = strlenW(es->undo_text);
2829 if (!es->undo_insert_count && (*es->undo_text && (s == es->undo_position))) {
2830 /* undo-buffer is extended to the right */
2831 EDIT_MakeUndoFit(es, utl + e - s);
2832 strncpyW(es->undo_text + utl, es->text + s, e - s + 1);
2833 (es->undo_text + utl)[e - s] = 0; /* ensure 0 termination */
2834 } else if (!es->undo_insert_count && (*es->undo_text && (e == es->undo_position))) {
2835 /* undo-buffer is extended to the left */
2836 EDIT_MakeUndoFit(es, utl + e - s);
2837 for (p = es->undo_text + utl ; p >= es->undo_text ; p--)
2838 p[e - s] = p[0];
2839 for (i = 0 , p = es->undo_text ; i < e - s ; i++)
2840 p[i] = (es->text + s)[i];
2841 es->undo_position = s;
2842 } else {
2843 /* new undo-buffer */
2844 EDIT_MakeUndoFit(es, e - s);
2845 strncpyW(es->undo_text, es->text + s, e - s + 1);
2846 es->undo_text[e - s] = 0; /* ensure 0 termination */
2847 es->undo_position = s;
2848 }
2849 /* any deletion makes the old insertion-undo invalid */
2850 es->undo_insert_count = 0;
2851 } else
2852 EDIT_EM_EmptyUndoBuffer(es);
2853
2854 /* now delete */
2855 strcpyW(es->text + s, es->text + e);
2856 }
2857 if (strl) {
2858 /* there is an insertion */
2859 if (can_undo) {
2860 if ((s == es->undo_position) ||
2861 ((es->undo_insert_count) &&
2862 (s == es->undo_position + es->undo_insert_count)))
2863 /*
2864 * insertion is new and at delete position or
2865 * an extension to either left or right
2866 */
2867 es->undo_insert_count += strl;
2868 else {
2869 /* new insertion undo */
2870 es->undo_position = s;
2871 es->undo_insert_count = strl;
2872 /* new insertion makes old delete-buffer invalid */
2873 *es->undo_text = '\0';
2874 }
2875 } else
2876 EDIT_EM_EmptyUndoBuffer(es);
2877
2878 /* now insert */
2879 tl = strlenW(es->text);
2880 for (p = es->text + tl ; p >= es->text + s ; p--)
2881 p[strl] = p[0];
2882 for (i = 0 , p = es->text + s ; i < strl ; i++)
2883 p[i] = lpsz_replace[i];
2884 if(es->style & ES_UPPERCASE)
2885 CharUpperBuffW(p, strl);
2886 else if(es->style & ES_LOWERCASE)
2887 CharLowerBuffW(p, strl);
2888 s += strl;
2889 }
2890 /* FIXME: really inefficient */
2891 if (es->style & ES_MULTILINE)
2892 EDIT_BuildLineDefs_ML(wnd, es);
2893 else
2894 EDIT_CalcLineWidth_SL(wnd, es);
2895
2896 EDIT_EM_SetSel(wnd, es, s, s, FALSE);
2897 es->flags |= EF_MODIFIED;
2898 if (send_update) es->flags |= EF_UPDATE;
2899 EDIT_EM_ScrollCaret(wnd, es);
2900
2901 /* force scroll info update */
2902 EDIT_UpdateScrollInfo(wnd, es);
2903
2904 /* FIXME: really inefficient */
2905 EDIT_UpdateText(wnd, NULL, TRUE);
2906 }
2907
2908
2909 /*********************************************************************
2910 *
2911 * EM_SCROLL
2912 *
2913 */
2914 static LRESULT EDIT_EM_Scroll(WND *wnd, EDITSTATE *es, INT action)
2915 {
2916 INT dy;
2917
2918 if (!(es->style & ES_MULTILINE))
2919 return (LRESULT)FALSE;
2920
2921 dy = 0;
2922
2923 switch (action) {
2924 case SB_LINEUP:
2925 if (es->y_offset)
2926 dy = -1;
2927 break;
2928 case SB_LINEDOWN:
2929 if (es->y_offset < es->line_count - 1)
2930 dy = 1;
2931 break;
2932 case SB_PAGEUP:
2933 if (es->y_offset)
2934 dy = -(es->format_rect.bottom - es->format_rect.top) / es->line_height;
2935 break;
2936 case SB_PAGEDOWN:
2937 if (es->y_offset < es->line_count - 1)
2938 dy = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
2939 break;
2940 default:
2941 return (LRESULT)FALSE;
2942 }
2943 if (dy) {
2944 INT vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
2945 /* check if we are going to move too far */
2946 if(es->y_offset + dy > es->line_count - vlc)
2947 dy = es->line_count - vlc - es->y_offset;
2948
2949 /* Notification is done in EDIT_EM_LineScroll */
2950 if(dy)
2951 EDIT_EM_LineScroll(wnd, es, 0, dy);
2952 }
2953 return MAKELONG((INT16)dy, (BOOL16)TRUE);
2954 }
2955
2956
2957 /*********************************************************************
2958 *
2959 * EM_SCROLLCARET
2960 *
2961 */
2962 static void EDIT_EM_ScrollCaret(WND *wnd, EDITSTATE *es)
2963 {
2964 if (es->style & ES_MULTILINE) {
2965 INT l;
2966 INT li;
2967 INT vlc;
2968 INT ww;
2969 INT cw = es->char_width;
2970 INT x;
2971 INT dy = 0;
2972 INT dx = 0;
2973
2974 l = EDIT_EM_LineFromChar(es, es->selection_end);
2975 li = EDIT_EM_LineIndex(es, l);
2976 x = SLOWORD(EDIT_EM_PosFromChar(wnd, es, es->selection_end, es->flags & EF_AFTER_WRAP));
2977 vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
2978 if (l >= es->y_offset + vlc)
2979 dy = l - vlc + 1 - es->y_offset;
2980 if (l < es->y_offset)
2981 dy = l - es->y_offset;
2982 ww = es->format_rect.right - es->format_rect.left;
2983 if (x < es->format_rect.left)
2984 dx = x - es->format_rect.left - ww / HSCROLL_FRACTION / cw * cw;
2985 if (x > es->format_rect.right)
2986 dx = x - es->format_rect.left - (HSCROLL_FRACTION - 1) * ww / HSCROLL_FRACTION / cw * cw;
2987 if (dy || dx)
2988 {
2989 /* check if we are going to move too far */
2990 if(es->x_offset + dx + ww > es->text_width)
2991 dx = es->text_width - ww - es->x_offset;
2992 if(dx || dy)
2993 EDIT_EM_LineScroll_internal(wnd, es, dx, dy);
2994 }
2995 } else {
2996 INT x;
2997 INT goal;
2998 INT format_width;
2999
3000 if (!(es->style & ES_AUTOHSCROLL))
3001 return;
3002
3003 x = SLOWORD(EDIT_EM_PosFromChar(wnd, es, es->selection_end, FALSE));
3004 format_width = es->format_rect.right - es->format_rect.left;
3005 if (x < es->format_rect.left) {
3006 goal = es->format_rect.left + format_width / HSCROLL_FRACTION;
3007 do {
3008 es->x_offset--;
3009 x = SLOWORD(EDIT_EM_PosFromChar(wnd, es, es->selection_end, FALSE));
3010 } while ((x < goal) && es->x_offset);
3011 /* FIXME: use ScrollWindow() somehow to improve performance */
3012 EDIT_UpdateText(wnd, NULL, TRUE);
3013 } else if (x > es->format_rect.right) {
3014 INT x_last;
3015 INT len = strlenW(es->text);
3016 goal = es->format_rect.right - format_width / HSCROLL_FRACTION;
3017 do {
3018 es->x_offset++;
3019 x = SLOWORD(EDIT_EM_PosFromChar(wnd, es, es->selection_end, FALSE));
3020 x_last = SLOWORD(EDIT_EM_PosFromChar(wnd, es, len, FALSE));
3021 } while ((x > goal) && (x_last > es->format_rect.right));
3022 /* FIXME: use ScrollWindow() somehow to improve performance */
3023 EDIT_UpdateText(wnd, NULL, TRUE);
3024 }
3025 }
3026
3027 if(es->flags & EF_FOCUSED)
3028 EDIT_SetCaretPos(wnd, es, es->selection_end, es->flags & EF_AFTER_WRAP);
3029 }
3030
3031
3032 /*********************************************************************
3033 *
3034 * EM_SETHANDLE
3035 *
3036 * FIXME: ES_LOWERCASE, ES_UPPERCASE, ES_OEMCONVERT, ES_NUMBER ???
3037 *
3038 */
3039 static void EDIT_EM_SetHandle(WND *wnd, EDITSTATE *es, HLOCAL hloc)
3040 {
3041 if (!(es->style & ES_MULTILINE))
3042 return;
3043
3044 if (!hloc) {
3045 WARN("called with NULL handle\n");
3046 return;
3047 }
3048
3049 EDIT_UnlockBuffer(wnd, es, TRUE);
3050
3051 if(es->hloc16)
3052 {
3053 LOCAL_Free(wnd->hInstance, es->hloc16);
3054 es->hloc16 = (HLOCAL16)NULL;
3055 }
3056
3057 if(es->is_unicode)
3058 {
3059 if(es->hloc32A)
3060 {
3061 LocalFree(es->hloc32A);
3062 es->hloc32A = (HLOCAL)NULL;
3063 }
3064 es->hloc32W = hloc;
3065 }
3066 else
3067 {
3068 INT countW, countA;
3069 HLOCAL hloc32W_new;
3070 WCHAR *textW;
3071 CHAR *textA;
3072
3073 countA = LocalSize(hloc);
3074 textA = LocalLock(hloc);
3075 countW = MultiByteToWideChar(CP_ACP, 0, textA, countA, NULL, 0);
3076 if(!(hloc32W_new = LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT, countW * sizeof(WCHAR))))
3077 {
3078 ERR("Could not allocate new unicode buffer\n");
3079 return;
3080 }
3081 textW = LocalLock(hloc32W_new);
3082 MultiByteToWideChar(CP_ACP, 0, textA, countA, textW, countW);
3083 LocalUnlock(hloc32W_new);
3084 LocalUnlock(hloc);
3085
3086 if(es->hloc32W)
3087 LocalFree(es->hloc32W);
3088
3089 es->hloc32W = hloc32W_new;
3090 es->hloc32A = hloc;
3091 }
3092
3093 es->buffer_size = LocalSize(es->hloc32W)/sizeof(WCHAR) - 1;
3094
3095 EDIT_LockBuffer(wnd, es);
3096
3097 es->x_offset = es->y_offset = 0;
3098 es->selection_start = es->selection_end = 0;
3099 EDIT_EM_EmptyUndoBuffer(es);
3100 es->flags &= ~EF_MODIFIED;
3101 es->flags &= ~EF_UPDATE;
3102 EDIT_BuildLineDefs_ML(wnd, es);
3103 EDIT_UpdateText(wnd, NULL, TRUE);
3104 EDIT_EM_ScrollCaret(wnd, es);
3105 /* force scroll info update */
3106 EDIT_UpdateScrollInfo(wnd, es);
3107 }
3108
3109
3110 /*********************************************************************
3111 *
3112 * EM_SETHANDLE16
3113 *
3114 * FIXME: ES_LOWERCASE, ES_UPPERCASE, ES_OEMCONVERT, ES_NUMBER ???
3115 *
3116 */
3117 static void EDIT_EM_SetHandle16(WND *wnd, EDITSTATE *es, HLOCAL16 hloc)
3118 {
3119 INT countW, countA;
3120 HLOCAL hloc32W_new;
3121 WCHAR *textW;
3122 CHAR *textA;
3123
3124 if (!(es->style & ES_MULTILINE))
3125 return;
3126
3127 if (!hloc) {
3128 WARN("called with NULL handle\n");
3129 return;
3130 }
3131
3132 EDIT_UnlockBuffer(wnd, es, TRUE);
3133
3134 if(es->hloc32A)
3135 {
3136 LocalFree(es->hloc32A);
3137 es->hloc32A = (HLOCAL)NULL;
3138 }
3139
3140 countA = LOCAL_Size(wnd->hInstance, hloc);
3141 textA = LOCAL_Lock(wnd->hInstance, hloc);
3142 countW = MultiByteToWideChar(CP_ACP, 0, textA, countA, NULL, 0);
3143 if(!(hloc32W_new = LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT, countW * sizeof(WCHAR))))
3144 {
3145 ERR("Could not allocate new unicode buffer\n");
3146 return;
3147 }
3148 textW = LocalLock(hloc32W_new);
3149 MultiByteToWideChar(CP_ACP, 0, textA, countA, textW, countW);
3150 LocalUnlock(hloc32W_new);
3151 LOCAL_Unlock(wnd->hInstance, hloc);
3152
3153 if(es->hloc32W)
3154 LocalFree(es->hloc32W);
3155
3156 es->hloc32W = hloc32W_new;
3157 es->hloc16 = hloc;
3158
3159 es->buffer_size = LocalSize(es->hloc32W)/sizeof(WCHAR) - 1;
3160
3161 EDIT_LockBuffer(wnd, es);
3162
3163 es->x_offset = es->y_offset = 0;
3164 es->selection_start = es->selection_end = 0;
3165 EDIT_EM_EmptyUndoBuffer(es);
3166 es->flags &= ~EF_MODIFIED;
3167 es->flags &= ~EF_UPDATE;
3168 EDIT_BuildLineDefs_ML(wnd, es);
3169 EDIT_UpdateText(wnd, NULL, TRUE);
3170 EDIT_EM_ScrollCaret(wnd, es);
3171 /* force scroll info update */
3172 EDIT_UpdateScrollInfo(wnd, es);
3173 }
3174
3175
3176 /*********************************************************************
3177 *
3178 * EM_SETLIMITTEXT
3179 *
3180 * FIXME: in WinNT maxsize is 0x7FFFFFFF / 0xFFFFFFFF
3181 * However, the windows version is not complied to yet in all of edit.c
3182 *
3183 */
3184 static void EDIT_EM_SetLimitText(EDITSTATE *es, INT limit)
3185 {
3186 if (es->style & ES_MULTILINE) {
3187 if (limit)
3188 es->buffer_limit = min(limit, BUFLIMIT_MULTI);
3189 else
3190 es->buffer_limit = BUFLIMIT_MULTI;
3191 } else {
3192 if (limit)
3193 es->buffer_limit = min(limit, BUFLIMIT_SINGLE);
3194 else
3195 es->buffer_limit = BUFLIMIT_SINGLE;
3196 }
3197 }
3198
3199
3200 /*********************************************************************
3201 *
3202 * EM_SETMARGINS
3203 *
3204 * EC_USEFONTINFO is used as a left or right value i.e. lParam and not as an
3205 * action wParam despite what the docs say. EC_USEFONTINFO means one third
3206 * of the char's width, according to the new docs.
3207 *
3208 */
3209 static void EDIT_EM_SetMargins(EDITSTATE *es, INT action,
3210 INT left, INT right)
3211 {
3212 if (action & EC_LEFTMARGIN) {
3213 if (left != EC_USEFONTINFO)
3214 es->left_margin = left;
3215 else
3216 es->left_margin = es->char_width / 3;
3217 }
3218
3219 if (action & EC_RIGHTMARGIN) {
3220 if (right != EC_USEFONTINFO)
3221 es->right_margin = right;
3222 else
3223 es->right_margin = es->char_width / 3;
3224 }
3225 TRACE("left=%d, right=%d\n", es->left_margin, es->right_margin);
3226 }
3227
3228
3229 /*********************************************************************
3230 *
3231 * EM_SETPASSWORDCHAR
3232 *
3233 */
3234 static void EDIT_EM_SetPasswordChar(WND *wnd, EDITSTATE *es, WCHAR c)
3235 {
3236 if (es->style & ES_MULTILINE)
3237 return;
3238
3239 if (es->password_char == c)
3240 return;
3241
3242 es->password_char = c;
3243 if (c) {
3244 wnd->dwStyle |= ES_PASSWORD;
3245 es->style |= ES_PASSWORD;
3246 } else {
3247 wnd->dwStyle &= ~ES_PASSWORD;
3248 es->style &= ~ES_PASSWORD;
3249 }
3250 EDIT_UpdateText(wnd, NULL, TRUE);
3251 }
3252
3253
3254 /*********************************************************************
3255 *
3256 * EDIT_EM_SetSel
3257 *
3258 * note: unlike the specs say: the order of start and end
3259 * _is_ preserved in Windows. (i.e. start can be > end)
3260 * In other words: this handler is OK
3261 *
3262 */
3263 static void EDIT_EM_SetSel(WND *wnd, EDITSTATE *es, UINT start, UINT end, BOOL after_wrap)
3264 {
3265 UINT old_start = es->selection_start;
3266 UINT old_end = es->selection_end;
3267 UINT len = strlenW(es->text);
3268
3269 if (start == (UINT)-1) {
3270 start = es->selection_end;
3271 end = es->selection_end;
3272 } else {
3273 start = min(start, len);
3274 end = min(end, len);
3275 }
3276 es->selection_start = start;
3277 es->selection_end = end;
3278 if (after_wrap)
3279 es->flags |= EF_AFTER_WRAP;
3280 else
3281 es->flags &= ~EF_AFTER_WRAP;
3282 /* This is a little bit more efficient than before, not sure if it can be improved. FIXME? */
3283 ORDER_UINT(start, end);
3284 ORDER_UINT(end, old_end);
3285 ORDER_UINT(start, old_start);
3286 ORDER_UINT(old_start, old_end);
3287 if (end != old_start)
3288 {
3289 /*
3290 * One can also do
3291 * ORDER_UINT32(end, old_start);
3292 * EDIT_InvalidateText(wnd, es, start, end);
3293 * EDIT_InvalidateText(wnd, es, old_start, old_end);
3294 * in place of the following if statement.
3295 */
3296 if (old_start > end )
3297 {
3298 EDIT_InvalidateText(wnd, es, start, end);
3299 EDIT_InvalidateText(wnd, es, old_start, old_end);
3300 }
3301 else
3302 {
3303 EDIT_InvalidateText(wnd, es, start, old_start);
3304 EDIT_InvalidateText(wnd, es, end, old_end);
3305 }
3306 }
3307 else EDIT_InvalidateText(wnd, es, start, old_end);
3308 }
3309
3310
3311 /*********************************************************************
3312 *
3313 * EM_SETTABSTOPS
3314 *
3315 */
3316 static BOOL EDIT_EM_SetTabStops(EDITSTATE *es, INT count, LPINT tabs)
3317 {
3318 if (!(es->style & ES_MULTILINE))
3319 return FALSE;
3320 if (es->tabs)
3321 HeapFree(GetProcessHeap(), 0, es->tabs);
3322 es->tabs_count = count;
3323 if (!count)
3324 es->tabs = NULL;
3325 else {
3326 es->tabs = HeapAlloc(GetProcessHeap(), 0, count * sizeof(INT));
3327 memcpy(es->tabs, tabs, count * sizeof(INT));
3328 }
3329 return TRUE;
3330 }
3331
3332
3333 /*********************************************************************
3334 *
3335 * EM_SETTABSTOPS16
3336 *
3337 */
3338 static BOOL EDIT_EM_SetTabStops16(EDITSTATE *es, INT count, LPINT16 tabs)
3339 {
3340 if (!(es->style & ES_MULTILINE))
3341 return FALSE;
3342 if (es->tabs)
3343 HeapFree(GetProcessHeap(), 0, es->tabs);
3344 es->tabs_count = count;
3345 if (!count)
3346 es->tabs = NULL;
3347 else {
3348 INT i;
3349 es->tabs = HeapAlloc(GetProcessHeap(), 0, count * sizeof(INT));
3350 for (i = 0 ; i < count ; i++)
3351 es->tabs[i] = *tabs++;
3352 }
3353 return TRUE;
3354 }
3355
3356
3357 /*********************************************************************
3358 *
3359 * EM_SETWORDBREAKPROC
3360 *
3361 */
3362 static void EDIT_EM_SetWordBreakProc(WND *wnd, EDITSTATE *es, LPARAM lParam)
3363 {
3364 if (es->word_break_proc == (void *)lParam)
3365 return;
3366
3367 es->word_break_proc = (void *)lParam;
3368 es->word_break_proc16 = NULL;
3369
3370 if ((es->style & ES_MULTILINE) && !(es->style & ES_AUTOHSCROLL)) {
3371 EDIT_BuildLineDefs_ML(wnd, es);
3372 EDIT_UpdateText(wnd, NULL, TRUE);
3373 }
3374 }
3375
3376
3377 /*********************************************************************
3378 *
3379 * EM_SETWORDBREAKPROC16
3380 *
3381 */
3382 static void EDIT_EM_SetWordBreakProc16(WND *wnd, EDITSTATE *es, EDITWORDBREAKPROC16 wbp)
3383 {
3384 if (es->word_break_proc16 == wbp)
3385 return;
3386
3387 es->word_break_proc = NULL;
3388 es->word_break_proc16 = wbp;
3389 if ((es->style & ES_MULTILINE) && !(es->style & ES_AUTOHSCROLL)) {
3390 EDIT_BuildLineDefs_ML(wnd, es);
3391 EDIT_UpdateText(wnd, NULL, TRUE);
3392 }
3393 }
3394
3395
3396 /*********************************************************************
3397 *
3398 * EM_UNDO / WM_UNDO
3399 *
3400 */
3401 static BOOL EDIT_EM_Undo(WND *wnd, EDITSTATE *es)
3402 {
3403 INT ulength = strlenW(es->undo_text);
3404 LPWSTR utext = HeapAlloc(GetProcessHeap(), 0, (ulength + 1) * sizeof(WCHAR));
3405
3406 strcpyW(utext, es->undo_text);
3407
3408 TRACE("before UNDO:insertion length = %d, deletion buffer = %s\n",
3409 es->undo_insert_count, debugstr_w(utext));
3410
3411 EDIT_EM_SetSel(wnd, es, es->undo_position, es->undo_position + es->undo_insert_count, FALSE);
3412 EDIT_EM_EmptyUndoBuffer(es);
3413 EDIT_EM_ReplaceSel(wnd, es, TRUE, utext, TRUE);
3414 EDIT_EM_SetSel(wnd, es, es->undo_position, es->undo_position + es->undo_insert_count, FALSE);
3415 EDIT_EM_ScrollCaret(wnd, es);
3416 HeapFree(GetProcessHeap(), 0, utext);
3417
3418 TRACE("after UNDO:insertion length = %d, deletion buffer = %s\n",
3419 es->undo_insert_count, debugstr_w(es->undo_text));
3420
3421 if (es->flags & EF_UPDATE) {
3422 es->flags &= ~EF_UPDATE;
3423 EDIT_NOTIFY_PARENT(wnd, EN_CHANGE, "EN_CHANGE");
3424 }
3425
3426 return TRUE;
3427 }
3428
3429
3430 /*********************************************************************
3431 *
3432 * WM_CHAR
3433 *
3434 */
3435 static void EDIT_WM_Char(WND *wnd, EDITSTATE *es, WCHAR c)
3436 {
3437 BOOL control = GetKeyState(VK_CONTROL) & 0x8000;
3438 switch (c) {
3439 case '\r':
3440 /* If the edit doesn't want the return and it's not a multiline edit, do nothing */
3441 if(!(es->style & ES_MULTILINE) && !(es->style & ES_WANTRETURN))
3442 break;
3443 case '\n':
3444 if (es->style & ES_MULTILINE) {
3445 if (es->style & ES_READONLY) {
3446 EDIT_MoveHome(wnd, es, FALSE);
3447 EDIT_MoveDown_ML(wnd, es, FALSE);
3448 } else {
3449 static const WCHAR cr_lfW[] = {'\r','\n',0};
3450 EDIT_EM_ReplaceSel(wnd, es, TRUE, cr_lfW, TRUE);
3451 if (es->flags & EF_UPDATE) {
3452 es->flags &= ~EF_UPDATE;
3453 EDIT_NOTIFY_PARENT(wnd, EN_CHANGE, "EN_CHANGE");
3454 }
3455 }
3456 }
3457 break;
3458 case '\t':
3459 if ((es->style & ES_MULTILINE) && !(es->style & ES_READONLY))
3460 {
3461 static const WCHAR tabW[] = {'\t',0};
3462 EDIT_EM_ReplaceSel(wnd, es, TRUE, tabW, TRUE);
3463 if (es->flags & EF_UPDATE) {
3464 es->flags &= ~EF_UPDATE;
3465 EDIT_NOTIFY_PARENT(wnd, EN_CHANGE, "EN_CHANGE");
3466 }
3467 }
3468 break;
3469 case VK_BACK:
3470 if (!(es->style & ES_READONLY) && !control) {
3471 if (es->selection_start != es->selection_end)
3472 EDIT_WM_Clear(wnd, es);
3473 else {
3474 /* delete character left of caret */
3475 EDIT_EM_SetSel(wnd, es, (UINT)-1, 0, FALSE);
3476 EDIT_MoveBackward(wnd, es, TRUE);
3477 EDIT_WM_Clear(wnd, es);
3478 }
3479 }
3480 break;
3481 case 0x03: /* ^C */
3482 SendMessageW(wnd->hwndSelf, WM_COPY, 0, 0);
3483 break;
3484 case 0x16: /* ^V */
3485 SendMessageW(wnd->hwndSelf, WM_PASTE, 0, 0);
3486 break;
3487 case 0x18: /* ^X */
3488 SendMessageW(wnd->hwndSelf, WM_CUT, 0, 0);
3489 break;
3490
3491 default:
3492 if (!(es->style & ES_READONLY) && (c >= ' ') && (c != 127)) {
3493 WCHAR str[2];
3494 str[0] = c;
3495 str[1] = '\0';
3496 EDIT_EM_ReplaceSel(wnd, es, TRUE, str, TRUE);
3497 if (es->flags & EF_UPDATE) {
3498 es->flags &= ~EF_UPDATE;
3499 EDIT_NOTIFY_PARENT(wnd, EN_CHANGE, "EN_CHANGE");
3500 }
3501 }
3502 break;
3503 }
3504 }
3505
3506
3507 /*********************************************************************
3508 *
3509 * WM_COMMAND
3510 *
3511 */
3512 static void EDIT_WM_Command(WND *wnd, EDITSTATE *es, INT code, INT id, HWND control)
3513 {
3514 if (code || control)
3515 return;
3516
3517 switch (id) {
3518 case EM_UNDO:
3519 EDIT_EM_Undo(wnd, es);
3520 break;
3521 case WM_CUT:
3522 EDIT_WM_Cut(wnd, es);
3523 break;
3524 case WM_COPY:
3525 EDIT_WM_Copy(wnd, es);
3526 break;
3527 case WM_PASTE:
3528 EDIT_WM_Paste(wnd, es);
3529 break;
3530 case WM_CLEAR:
3531 EDIT_WM_Clear(wnd, es);
3532 break;
3533 case EM_SETSEL:
3534 EDIT_EM_SetSel(wnd, es, 0, (UINT)-1, FALSE);
3535 EDIT_EM_ScrollCaret(wnd, es);
3536 break;
3537 default:
3538 ERR("unknown menu item, please report\n");
3539 break;
3540 }
3541 }
3542
3543
3544 /*********************************************************************
3545 *
3546 * WM_CONTEXTMENU
3547 *
3548 * Note: the resource files resource/sysres_??.rc cannot define a
3549 * single popup menu. Hence we use a (dummy) menubar
3550 * containing the single popup menu as its first item.
3551 *
3552 * FIXME: the message identifiers have been chosen arbitrarily,
3553 * hence we use MF_BYPOSITION.
3554 * We might as well use the "real" values (anybody knows ?)
3555 * The menu definition is in resources/sysres_??.rc.
3556 * Once these are OK, we better use MF_BYCOMMAND here
3557 * (as we do in EDIT_WM_Command()).
3558 *
3559 */
3560 static void EDIT_WM_ContextMenu(WND *wnd, EDITSTATE *es, INT x, INT y)
3561 {
3562 HMENU menu = LoadMenuA(GetModuleHandleA("USER32"), "EDITMENU");
3563 HMENU popup = GetSubMenu(menu, 0);
3564 UINT start = es->selection_start;
3565 UINT end = es->selection_end;
3566
3567 ORDER_UINT(start, end);
3568
3569 /* undo */
3570 EnableMenuItem(popup, 0, MF_BYPOSITION | (EDIT_EM_CanUndo(es) ? MF_ENABLED : MF_GRAYED));
3571 /* cut */
3572 EnableMenuItem(popup, 2, MF_BYPOSITION | ((end - start) && !(es->style & ES_PASSWORD) ? MF_ENABLED : MF_GRAYED));
3573 /* copy */
3574 EnableMenuItem(popup, 3, MF_BYPOSITION | ((end - start) && !(es->style & ES_PASSWORD) ? MF_ENABLED : MF_GRAYED));
3575 /* paste */
3576 EnableMenuItem(popup, 4, MF_BYPOSITION | (IsClipboardFormatAvailable(CF_UNICODETEXT) ? MF_ENABLED : MF_GRAYED));
3577 /* delete */
3578 EnableMenuItem(popup, 5, MF_BYPOSITION | ((end - start) ? MF_ENABLED : MF_GRAYED));
3579 /* select all */
3580 EnableMenuItem(popup, 7, MF_BYPOSITION | (start || (end != strlenW(es->text)) ? MF_ENABLED : MF_GRAYED));
3581
3582 TrackPopupMenu(popup, TPM_LEFTALIGN | TPM_RIGHTBUTTON, x, y, 0, wnd->hwndSelf, NULL);
3583 DestroyMenu(menu);
3584 }
3585
3586
3587 /*********************************************************************
3588 *
3589 * WM_COPY
3590 *
3591 */
3592 static void EDIT_WM_Copy(WND *wnd, EDITSTATE *es)
3593 {
3594 INT s = es->selection_start;
3595 INT e = es->selection_end;
3596 HGLOBAL hdst;
3597 LPWSTR dst;
3598
3599 if (e == s)
3600 return;
3601 ORDER_INT(s, e);
3602 hdst = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, (DWORD)(e - s + 1) * sizeof(WCHAR));
3603 dst = GlobalLock(hdst);
3604 strncpyW(dst, es->text + s, e - s);
3605 dst[e - s] = 0; /* ensure 0 termination */
3606 TRACE("%s\n", debugstr_w(dst));
3607 GlobalUnlock(hdst);
3608 OpenClipboard(wnd->hwndSelf);
3609 EmptyClipboard();
3610 SetClipboardData(CF_UNICODETEXT, hdst);
3611 CloseClipboard();
3612 }
3613
3614
3615 /*********************************************************************
3616 *
3617 * WM_CREATE
3618 *
3619 */
3620 static LRESULT EDIT_WM_Create(WND *wnd, EDITSTATE *es, LPCWSTR name)
3621 {
3622 TRACE("%s\n", debugstr_w(name));
3623 /*
3624 * To initialize some final structure members, we call some helper
3625 * functions. However, since the EDITSTATE is not consistent (i.e.
3626 * not fully initialized), we should be very careful which
3627 * functions can be called, and in what order.
3628 */
3629 EDIT_WM_SetFont(wnd, es, 0, FALSE);
3630 EDIT_EM_EmptyUndoBuffer(es);
3631
3632 if (name && *name) {
3633 EDIT_EM_ReplaceSel(wnd, es, FALSE, name, TRUE);
3634 /* if we insert text to the editline, the text scrolls out
3635 * of the window, as the caret is placed after the insert
3636 * pos normally; thus we reset es->selection... to 0 and
3637 * update caret
3638 */
3639 es->selection_start = es->selection_end = 0;
3640 EDIT_EM_ScrollCaret(wnd, es);
3641 if (es->flags & EF_UPDATE) {
3642 es->flags &= ~EF_UPDATE;
3643 EDIT_NOTIFY_PARENT(wnd, EN_CHANGE, "EN_CHANGE");
3644 }
3645 }
3646 /* force scroll info update */
3647 EDIT_UpdateScrollInfo(wnd, es);
3648 return 0;
3649 }
3650
3651
3652 /*********************************************************************
3653 *
3654 * WM_DESTROY
3655 *
3656 */
3657 static void EDIT_WM_Destroy(WND *wnd, EDITSTATE *es)
3658 {
3659 if (es->hloc32W) {
3660 while (LocalUnlock(es->hloc32W)) ;
3661 LocalFree(es->hloc32W);
3662 }
3663 if (es->hloc32A) {
3664 while (LocalUnlock(es->hloc32A)) ;
3665 LocalFree(es->hloc32A);
3666 }
3667 if (es->hloc16) {
3668 while (LOCAL_Unlock(wnd->hInstance, es->hloc16)) ;
3669 LOCAL_Free(wnd->hInstance, es->hloc16);
3670 }
3671 HeapFree(GetProcessHeap(), 0, es);
3672 *(EDITSTATE **)wnd->wExtra = NULL;
3673 }
3674
3675
3676 /*********************************************************************
3677 *
3678 * WM_ERASEBKGND
3679 *
3680 */
3681 static LRESULT EDIT_WM_EraseBkGnd(WND *wnd, EDITSTATE *es, HDC dc)
3682 {
3683 HBRUSH brush;
3684 RECT rc;
3685
3686 if ( get_app_version() >= 0x40000 &&(
3687 !es->bEnableState || (es->style & ES_READONLY)))
3688 brush = (HBRUSH)EDIT_SEND_CTLCOLORSTATIC(wnd, dc);
3689 else
3690 brush = (HBRUSH)EDIT_SEND_CTLCOLOR(wnd, dc);
3691
3692 if (!brush)
3693 brush = (HBRUSH)GetStockObject(WHITE_BRUSH);
3694
3695 GetClientRect(wnd->hwndSelf, &rc);
3696 IntersectClipRect(dc, rc.left, rc.top, rc.right, rc.bottom);
3697 GetClipBox(dc, &rc);
3698 /*
3699 * FIXME: specs say that we should UnrealizeObject() the brush,
3700 * but the specs of UnrealizeObject() say that we shouldn't
3701 * unrealize a stock object. The default brush that
3702 * DefWndProc() returns is ... a stock object.
3703 */
3704 FillRect(dc, &rc, brush);
3705 return -1;
3706 }
3707
3708
3709 /*********************************************************************
3710 *
3711 * WM_GETTEXT
3712 *
3713 */
3714 static INT EDIT_WM_GetText(EDITSTATE *es, INT count, LPARAM lParam, BOOL unicode)
3715 {
3716 if(!count) return 0;
3717
3718 if(unicode)
3719 {
3720 LPWSTR textW = (LPWSTR)lParam;
3721 strncpyW(textW, es->text, count);
3722 textW[count - 1] = 0; /* ensure 0 termination */
3723 return strlenW(textW);
3724 }
3725 else
3726 {
3727 LPSTR textA = (LPSTR)lParam;
3728 WideCharToMultiByte(CP_ACP, 0, es->text, -1, textA, count, NULL, NULL);
3729 textA[count - 1] = 0; /* ensure 0 termination */
3730 return strlen(textA);
3731 }
3732 }
3733
3734 /*********************************************************************
3735 *
3736 * WM_HSCROLL
3737 *
3738 */
3739 static LRESULT EDIT_WM_HScroll(WND *wnd, EDITSTATE *es, INT action, INT pos)
3740 {
3741 INT dx;
3742 INT fw;
3743
3744 if (!(es->style & ES_MULTILINE))
3745 return 0;
3746
3747 if (!(es->style & ES_AUTOHSCROLL))
3748 return 0;
3749
3750 dx = 0;
3751 fw = es->format_rect.right - es->format_rect.left;
3752 switch (action) {
3753 case SB_LINELEFT:
3754 TRACE("SB_LINELEFT\n");
3755 if (es->x_offset)
3756 dx = -es->char_width;
3757 break;
3758 case SB_LINERIGHT:
3759 TRACE("SB_LINERIGHT\n");
3760 if (es->x_offset < es->text_width)
3761 dx = es->char_width;
3762 break;
3763 case SB_PAGELEFT:
3764 TRACE("SB_PAGELEFT\n");
3765 if (es->x_offset)
3766 dx = -fw / HSCROLL_FRACTION / es->char_width * es->char_width;
3767 break;
3768 case SB_PAGERIGHT:
3769 TRACE("SB_PAGERIGHT\n");
3770 if (es->x_offset < es->text_width)
3771 dx = fw / HSCROLL_FRACTION / es->char_width * es->char_width;
3772 break;
3773 case SB_LEFT:
3774 TRACE("SB_LEFT\n");
3775 if (es->x_offset)
3776 dx = -es->x_offset;
3777 break;
3778 case SB_RIGHT:
3779 TRACE("SB_RIGHT\n");
3780 if (es->x_offset < es->text_width)
3781 dx = es->text_width - es->x_offset;
3782 break;
3783 case SB_THUMBTRACK:
3784 TRACE("SB_THUMBTRACK %d\n", pos);
3785 es->flags |= EF_HSCROLL_TRACK;
3786 if(es->style & WS_HSCROLL)
3787 dx = pos - es->x_offset;
3788 else
3789 {
3790 INT fw, new_x;
3791 /* Sanity check */
3792 if(pos < 0 || pos > 100) return 0;
3793 /* Assume default scroll range 0-100 */
3794 fw = es->format_rect.right - es->format_rect.left;
3795 new_x = pos * (es->text_width - fw) / 100;
3796 dx = es->text_width ? (new_x - es->x_offset) : 0;
3797 }
3798 break;
3799 case SB_THUMBPOSITION:
3800 TRACE("SB_THUMBPOSITION %d\n", pos);
3801 es->flags &= ~EF_HSCROLL_TRACK;
3802 if(wnd->dwStyle & WS_HSCROLL)
3803 dx = pos - es->x_offset;
3804 else
3805 {
3806 INT fw, new_x;
3807 /* Sanity check */
3808 if(pos < 0 || pos > 100) return 0;
3809 /* Assume default scroll range 0-100 */
3810 fw = es->format_rect.right - es->format_rect.left;
3811 new_x = pos * (es->text_width - fw) / 100;
3812 dx = es->text_width ? (new_x - es->x_offset) : 0;
3813 }
3814 if (!dx) {
3815 /* force scroll info update */
3816 EDIT_UpdateScrollInfo(wnd, es);
3817 EDIT_NOTIFY_PARENT(wnd, EN_HSCROLL, "EN_HSCROLL");
3818 }
3819 break;
3820 case SB_ENDSCROLL:
3821 TRACE("SB_ENDSCROLL\n");
3822 break;
3823 /*
3824 * FIXME : the next two are undocumented !
3825 * Are we doing the right thing ?
3826 * At least Win 3.1 Notepad makes use of EM_GETTHUMB this way,
3827 * although it's also a regular control message.
3828 */
3829 case EM_GETTHUMB: /* this one is used by NT notepad */
3830 case EM_GETTHUMB16:
3831 {
3832 LRESULT ret;
3833 if(wnd->dwStyle & WS_HSCROLL)
3834 ret = GetScrollPos(wnd->hwndSelf, SB_HORZ);
3835 else
3836 {
3837 /* Assume default scroll range 0-100 */
3838 INT fw = es->format_rect.right - es->format_rect.left;
3839 ret = es->text_width ? es->x_offset * 100 / (es->text_width - fw) : 0;
3840 }
3841 TRACE("EM_GETTHUMB: returning %ld\n", ret);
3842 return ret;
3843 }
3844 case EM_LINESCROLL16:
3845 TRACE("EM_LINESCROLL16\n");
3846 dx = pos;
3847 break;
3848
3849 default:
3850 ERR("undocumented WM_HSCROLL action %d (0x%04x), please report\n",
3851 action, action);
3852 return 0;
3853 }
3854 if (dx)
3855 {
3856 INT fw = es->format_rect.right - es->format_rect.left;
3857 /* check if we are going to move too far */
3858 if(es->x_offset + dx + fw > es->text_width)
3859 dx = es->text_width - fw - es->x_offset;
3860 if(dx)
3861 EDIT_EM_LineScroll_internal(wnd, es, dx, 0);
3862 }
3863 return 0;
3864 }
3865
3866
3867 /*********************************************************************
3868 *
3869 * EDIT_CheckCombo
3870 *
3871 */
3872 static BOOL EDIT_CheckCombo(WND *wnd, EDITSTATE *es, UINT msg, INT key)
3873 {
3874 HWND hLBox = es->hwndListBox;
3875 HWND hCombo;
3876 BOOL bDropped;
3877 int nEUI;
3878
3879 if (!hLBox)
3880 return FALSE;
3881
3882 hCombo = wnd->parent->hwndSelf;
3883 bDropped = TRUE;
3884 nEUI = 0;
3885
3886 TRACE_(combo)("[%04x]: handling msg %04x (%04x)\n",
3887 wnd->hwndSelf, (UINT16)msg, (UINT16)key);
3888
3889 if (key == VK_UP || key == VK_DOWN)
3890 {
3891 if (SendMessageW(hCombo, CB_GETEXTENDEDUI, 0, 0))
3892 nEUI = 1;
3893
3894 if (msg == WM_KEYDOWN || nEUI)
3895 bDropped = (BOOL)SendMessageW(hCombo, CB_GETDROPPEDSTATE, 0, 0);
3896 }
3897
3898 switch (msg)
3899 {
3900 case WM_KEYDOWN:
3901 if (!bDropped && nEUI && (key == VK_UP || key == VK_DOWN))
3902 {
3903 /* make sure ComboLBox pops up */
3904 SendMessageW(hCombo, CB_SETEXTENDEDUI, FALSE, 0);
3905 key = VK_F4;
3906 nEUI = 2;
3907 }
3908
3909 SendMessageW(hLBox, WM_KEYDOWN, (WPARAM)key, 0);
3910 break;
3911
3912 case WM_SYSKEYDOWN: /* Handle Alt+up/down arrows */
3913 if (nEUI)
3914 SendMessageW(hCombo, CB_SHOWDROPDOWN, bDropped ? FALSE : TRUE, 0);
3915 else
3916 SendMessageW(hLBox, WM_KEYDOWN, (WPARAM)VK_F4, 0);
3917 break;
3918 }
3919
3920 if(nEUI == 2)
3921 SendMessageW(hCombo, CB_SETEXTENDEDUI, TRUE, 0);
3922
3923 return TRUE;
3924 }
3925
3926
3927 /*********************************************************************
3928 *
3929 * WM_KEYDOWN
3930 *
3931 * Handling of special keys that don't produce a WM_CHAR
3932 * (i.e. non-printable keys) & Backspace & Delete
3933 *
3934 */
3935 static LRESULT EDIT_WM_KeyDown(WND *wnd, EDITSTATE *es, INT key)
3936 {
3937 BOOL shift;
3938 BOOL control;
3939
3940 if (GetKeyState(VK_MENU) & 0x8000)
3941 return 0;
3942
3943 shift = GetKeyState(VK_SHIFT) & 0x8000;
3944 control = GetKeyState(VK_CONTROL) & 0x8000;
3945
3946 switch (key) {
3947 case VK_F4:
3948 case VK_UP:
3949 if (EDIT_CheckCombo(wnd, es, WM_KEYDOWN, key) || key == VK_F4)
3950 break;
3951
3952 /* fall through */
3953 case VK_LEFT:
3954 if ((es->style & ES_MULTILINE) && (key == VK_UP))
3955 EDIT_MoveUp_ML(wnd, es, shift);
3956 else
3957 if (control)
3958 EDIT_MoveWordBackward(wnd, es, shift);
3959 else
3960 EDIT_MoveBackward(wnd, es, shift);
3961 break;
3962 case VK_DOWN:
3963 if (EDIT_CheckCombo(wnd, es, WM_KEYDOWN, key))
3964 break;
3965 /* fall through */
3966 case VK_RIGHT:
3967 if ((es->style & ES_MULTILINE) && (key == VK_DOWN))
3968 EDIT_MoveDown_ML(wnd, es, shift);
3969 else if (control)
3970 EDIT_MoveWordForward(wnd, es, shift);
3971 else
3972 EDIT_MoveForward(wnd, es, shift);
3973 break;
3974 case VK_HOME:
3975 EDIT_MoveHome(wnd, es, shift);
3976 break;
3977 case VK_END:
3978 EDIT_MoveEnd(wnd, es, shift);
3979 break;
3980 case VK_PRIOR:
3981 if (es->style & ES_MULTILINE)
3982 EDIT_MovePageUp_ML(wnd, es, shift);
3983 else
3984 EDIT_CheckCombo(wnd, es, WM_KEYDOWN, key);
3985 break;
3986 case VK_NEXT:
3987 if (es->style & ES_MULTILINE)
3988 EDIT_MovePageDown_ML(wnd, es, shift);
3989 else
3990 EDIT_CheckCombo(wnd, es, WM_KEYDOWN, key);
3991 break;
3992 case VK_DELETE:
3993 if (!(es->style & ES_READONLY) && !(shift && control)) {
3994 if (es->selection_start != es->selection_end) {
3995 if (shift)
3996 EDIT_WM_Cut(wnd, es);
3997 else
3998 EDIT_WM_Clear(wnd, es);
3999 } else {
4000 if (shift) {
4001 /* delete character left of caret */
4002 EDIT_EM_SetSel(wnd, es, (UINT)-1, 0, FALSE);
4003 EDIT_MoveBackward(wnd, es, TRUE);
4004 EDIT_WM_Clear(wnd, es);
4005 } else if (control) {
4006 /* delete to end of line */
4007 EDIT_EM_SetSel(wnd, es, (UINT)-1, 0, FALSE);
4008 EDIT_MoveEnd(wnd, es, TRUE);
4009 EDIT_WM_Clear(wnd, es);
4010 } else {
4011 /* delete character right of caret */
4012 EDIT_EM_SetSel(wnd, es, (UINT)-1, 0, FALSE);
4013 EDIT_MoveForward(wnd, es, TRUE);
4014 EDIT_WM_Clear(wnd, es);
4015 }
4016 }
4017 }
4018 break;
4019 case VK_INSERT:
4020 if (shift) {
4021 if (!(es->style & ES_READONLY))
4022 EDIT_WM_Paste(wnd, es);
4023 } else if (control)
4024 EDIT_WM_Copy(wnd, es);
4025 break;
4026 case VK_RETURN:
4027 /* If the edit doesn't want the return send a message to the default object */
4028 if(!(es->style & ES_WANTRETURN))
4029 {
4030 HWND hwndParent = GetParent(wnd->hwndSelf);
4031 DWORD dw = SendMessageW( hwndParent, DM_GETDEFID, 0, 0 );
4032 if (HIWORD(dw) == DC_HASDEFID)
4033 {
4034 SendMessageW( hwndParent, WM_COMMAND,
4035 MAKEWPARAM( LOWORD(dw), BN_CLICKED ),
4036 (LPARAM)GetDlgItem( hwndParent, LOWORD(dw) ) );
4037 }
4038 }
4039 break;
4040 }
4041 return 0;
4042 }
4043
4044
4045 /*********************************************************************
4046 *
4047 * WM_KILLFOCUS
4048 *
4049 */
4050 static LRESULT EDIT_WM_KillFocus(WND *wnd, EDITSTATE *es)
4051 {
4052 es->flags &= ~EF_FOCUSED;
4053 DestroyCaret();
4054 if(!(es->style & ES_NOHIDESEL))
4055 EDIT_InvalidateText(wnd, es, es->selection_start, es->selection_end);
4056 EDIT_NOTIFY_PARENT(wnd, EN_KILLFOCUS, "EN_KILLFOCUS");
4057 return 0;
4058 }
4059
4060
4061 /*********************************************************************
4062 *
4063 * WM_LBUTTONDBLCLK
4064 *
4065 * The caret position has been set on the WM_LBUTTONDOWN message
4066 *
4067 */
4068 static LRESULT EDIT_WM_LButtonDblClk(WND *wnd, EDITSTATE *es)
4069 {
4070 INT s;
4071 INT e = es->selection_end;
4072 INT l;
4073 INT li;
4074 INT ll;
4075
4076 if (!(es->flags & EF_FOCUSED))
4077 return 0;
4078
4079 l = EDIT_EM_LineFromChar(es, e);
4080 li = EDIT_EM_LineIndex(es, l);
4081 ll = EDIT_EM_LineLength(es, e);
4082 s = li + EDIT_CallWordBreakProc(es, li, e - li, ll, WB_LEFT);
4083 e = li + EDIT_CallWordBreakProc(es, li, e - li, ll, WB_RIGHT);
4084 EDIT_EM_SetSel(wnd, es, s, e, FALSE);
4085 EDIT_EM_ScrollCaret(wnd, es);
4086 return 0;
4087 }
4088
4089
4090 /*********************************************************************
4091 *
4092 * WM_LBUTTONDOWN
4093 *
4094 */
4095 static LRESULT EDIT_WM_LButtonDown(WND *wnd, EDITSTATE *es, DWORD keys, INT x, INT y)
4096 {
4097 INT e;
4098 BOOL after_wrap;
4099
4100 if (!(es->flags & EF_FOCUSED))
4101 return 0;
4102
4103 es->bCaptureState = TRUE;
4104 SetCapture(wnd->hwndSelf);
4105 EDIT_ConfinePoint(es, &x, &y);
4106 e = EDIT_CharFromPos(wnd, es, x, y, &after_wrap);
4107 EDIT_EM_SetSel(wnd, es, (keys & MK_SHIFT) ? es->selection_start : e, e, after_wrap);
4108 EDIT_EM_ScrollCaret(wnd, es);
4109 es->region_posx = es->region_posy = 0;
4110 SetTimer(wnd->hwndSelf, 0, 100, NULL);
4111 return 0;
4112 }
4113
4114
4115 /*********************************************************************
4116 *
4117 * WM_LBUTTONUP
4118 *
4119 */
4120 static LRESULT EDIT_WM_LButtonUp(HWND hwndSelf, EDITSTATE *es)
4121 {
4122 if (es->bCaptureState && GetCapture() == hwndSelf) {
4123 KillTimer(hwndSelf, 0);
4124 ReleaseCapture();
4125 }
4126 es->bCaptureState = FALSE;
4127 return 0;
4128 }
4129
4130
4131 /*********************************************************************
4132 *
4133 * WM_MBUTTONDOWN
4134 *
4135 */
4136 static LRESULT EDIT_WM_MButtonDown(WND *wnd)
4137 {
4138 SendMessageW(wnd->hwndSelf,WM_PASTE,0,0);
4139 return 0;
4140 }
4141
4142
4143 /*********************************************************************
4144 *
4145 * WM_MOUSEMOVE
4146 *
4147 */
4148 static LRESULT EDIT_WM_MouseMove(WND *wnd, EDITSTATE *es, INT x, INT y)
4149 {
4150 INT e;
4151 BOOL after_wrap;
4152 INT prex, prey;
4153
4154 if (GetCapture() != wnd->hwndSelf)
4155 return 0;
4156
4157 /*
4158 * FIXME: gotta do some scrolling if outside client
4159 * area. Maybe reset the timer ?
4160 */
4161 prex = x; prey = y;
4162 EDIT_ConfinePoint(es, &x, &y);
4163 es->region_posx = (prex < x) ? -1 : ((prex > x) ? 1 : 0);
4164 es->region_posy = (prey < y) ? -1 : ((prey > y) ? 1 : 0);
4165 e = EDIT_CharFromPos(wnd, es, x, y, &after_wrap);
4166 EDIT_EM_SetSel(wnd, es, es->selection_start, e, after_wrap);
4167 return 0;
4168 }
4169
4170
4171 /*********************************************************************
4172 *
4173 * WM_NCCREATE
4174 *
4175 */
4176 static LRESULT EDIT_WM_NCCreate(WND *wnd, DWORD style, HWND hwndParent, BOOL unicode)
4177 {
4178 EDITSTATE *es;
4179 UINT alloc_size;
4180
4181 TRACE("Creating %s edit control\n", unicode ? "Unicode" : "ANSI");
4182
4183 if (!(es = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*es))))
4184 return FALSE;
4185 *(EDITSTATE **)wnd->wExtra = es;
4186
4187 /*
4188 * Note: since the EDITSTATE has not been fully initialized yet,
4189 * we can't use any API calls that may send
4190 * WM_XXX messages before WM_NCCREATE is completed.
4191 */
4192
4193 es->is_unicode = unicode;
4194 es->style = style;
4195
4196 es->bEnableState = !(style & WS_DISABLED);
4197
4198 /*
4199 * In Win95 look and feel, the WS_BORDER style is replaced by the
4200 * WS_EX_CLIENTEDGE style for the edit control. This gives the edit
4201 * control a non client area.
4202 */
4203 if (TWEAK_WineLook != WIN31_LOOK)
4204 {
4205 if (es->style & WS_BORDER)
4206 {
4207 es->style &= ~WS_BORDER;
4208 wnd->dwStyle &= ~WS_BORDER;
4209 wnd->dwExStyle |= WS_EX_CLIENTEDGE;
4210 }
4211 }
4212 else
4213 {
4214 if ((es->style & WS_BORDER) && !(es->style & WS_DLGFRAME))
4215 wnd->dwStyle &= ~WS_BORDER;
4216 }
4217
4218 if (es->style & ES_COMBO)
4219 es->hwndListBox = GetDlgItem(hwndParent, ID_CB_LISTBOX);
4220
4221 if (es->style & ES_MULTILINE) {
4222 es->buffer_limit = BUFLIMIT_MULTI;
4223 if (es->style & WS_VSCROLL)
4224 es->style |= ES_AUTOVSCROLL;
4225 if (es->style & WS_HSCROLL)
4226 es->style |= ES_AUTOHSCROLL;
4227 es->style &= ~ES_PASSWORD;
4228 if ((es->style & ES_CENTER) || (es->style & ES_RIGHT)) {
4229 if (es->style & ES_RIGHT)
4230 es->style &= ~ES_CENTER;
4231 es->style &= ~WS_HSCROLL;
4232 es->style &= ~ES_AUTOHSCROLL;
4233 }
4234
4235 /* FIXME: for now, all multi line controls are AUTOVSCROLL */
4236 es->style |= ES_AUTOVSCROLL;
4237 } else {
4238 es->buffer_limit = BUFLIMIT_SINGLE;
4239 es->style &= ~ES_CENTER;
4240 es->style &= ~ES_RIGHT;
4241 es->style &= ~WS_HSCROLL;
4242 es->style &= ~WS_VSCROLL;
4243 es->style &= ~ES_AUTOVSCROLL;
4244 es->style &= ~ES_WANTRETURN;
4245 if (es->style & ES_UPPERCASE) {
4246 es->style &= ~ES_LOWERCASE;
4247 es->style &= ~ES_NUMBER;
4248 } else if (es->style & ES_LOWERCASE)
4249 es->style &= ~ES_NUMBER;
4250 if (es->style & ES_PASSWORD)
4251 es->password_char = '*';
4252
4253 /* FIXME: for now, all single line controls are AUTOHSCROLL */
4254 es->style |= ES_AUTOHSCROLL;
4255 }
4256
4257 alloc_size = ROUND_TO_GROW((es->buffer_size + 1) * sizeof(WCHAR));
4258 if(!(es->hloc32W = LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT, alloc_size)))
4259 return FALSE;
4260 es->buffer_size = LocalSize(es->hloc32W)/sizeof(WCHAR) - 1;
4261
4262 if (!(es->undo_text = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (es->buffer_size + 1) * sizeof(WCHAR))))
4263 return FALSE;
4264 es->undo_buffer_size = es->buffer_size;
4265
4266 if (es->style & ES_MULTILINE)
4267 if (!(es->first_line_def = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(LINEDEF))))
4268 return FALSE;
4269 es->line_count = 1;
4270
4271 return TRUE;
4272 }
4273
4274 /*********************************************************************
4275 *
4276 * WM_PAINT
4277 *
4278 */
4279 static void EDIT_WM_Paint(WND *wnd, EDITSTATE *es, WPARAM wParam)
4280 {
4281 PAINTSTRUCT ps;
4282 INT i;
4283 HDC dc;
4284 HFONT old_font = 0;
4285 RECT rc;
4286 RECT rcLine;
4287 RECT rcRgn;
4288 BOOL rev = es->bEnableState &&
4289 ((es->flags & EF_FOCUSED) ||
4290 (es->style & ES_NOHIDESEL));
4291 if (!wParam)
4292 dc = BeginPaint(wnd->hwndSelf, &ps);
4293 else
4294 dc = (HDC) wParam;
4295 if(es->style & WS_BORDER) {
4296 GetClientRect(wnd->hwndSelf, &rc);
4297 if(es->style & ES_MULTILINE) {
4298 if(es->style & WS_HSCROLL) rc.bottom++;
4299 if(es->style & WS_VSCROLL) rc.right++;
4300 }
4301 Rectangle(dc, rc.left, rc.top, rc.right, rc.bottom);
4302 }
4303 IntersectClipRect(dc, es->format_rect.left,
4304 es->format_rect.top,
4305 es->format_rect.right,
4306 es->format_rect.bottom);
4307 if (es->style & ES_MULTILINE) {
4308 GetClientRect(wnd->hwndSelf, &rc);
4309 IntersectClipRect(dc, rc.left, rc.top, rc.right, rc.bottom);
4310 }
4311 if (es->font)
4312 old_font = SelectObject(dc, es->font);
4313 if ( get_app_version() >= 0x40000 &&(
4314 !es->bEnableState || (es->style & ES_READONLY)))
4315 EDIT_SEND_CTLCOLORSTATIC(wnd, dc);
4316 else
4317 EDIT_SEND_CTLCOLOR(wnd, dc);
4318
4319 if (!es->bEnableState)
4320 SetTextColor(dc, GetSysColor(COLOR_GRAYTEXT));
4321 GetClipBox(dc, &rcRgn);
4322 if (es->style & ES_MULTILINE) {
4323 INT vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
4324 for (i = es->y_offset ; i <= min(es->y_offset + vlc, es->y_offset + es->line_count - 1) ; i++) {
4325 EDIT_GetLineRect(wnd, es, i, 0, -1, &rcLine);
4326 if (IntersectRect(&rc, &rcRgn, &rcLine))
4327 EDIT_PaintLine(wnd, es, dc, i, rev);
4328 }
4329 } else {
4330 EDIT_GetLineRect(wnd, es, 0, 0, -1, &rcLine);
4331 if (IntersectRect(&rc, &rcRgn, &rcLine))
4332 EDIT_PaintLine(wnd, es, dc, 0, rev);
4333 }
4334 if (es->font)
4335 SelectObject(dc, old_font);
4336
4337 if (!wParam)
4338 EndPaint(wnd->hwndSelf, &ps);
4339 }
4340
4341
4342 /*********************************************************************
4343 *
4344 * WM_PASTE
4345 *
4346 */
4347 static void EDIT_WM_Paste(WND *wnd, EDITSTATE *es)
4348 {
4349 HGLOBAL hsrc;
4350 LPWSTR src;
4351
4352 OpenClipboard(wnd->hwndSelf);
4353 if ((hsrc = GetClipboardData(CF_UNICODETEXT))) {
4354 src = (LPWSTR)GlobalLock(hsrc);
4355 EDIT_EM_ReplaceSel(wnd, es, TRUE, src, TRUE);
4356 GlobalUnlock(hsrc);
4357
4358 if (es->flags & EF_UPDATE) {
4359 es->flags &= ~EF_UPDATE;
4360 EDIT_NOTIFY_PARENT(wnd, EN_CHANGE, "EN_CHANGE");
4361 }
4362 }
4363 CloseClipboard();
4364 }
4365
4366
4367 /*********************************************************************
4368 *
4369 * WM_SETFOCUS
4370 *
4371 */
4372 static void EDIT_WM_SetFocus(WND *wnd, EDITSTATE *es)
4373 {
4374 es->flags |= EF_FOCUSED;
4375 CreateCaret(wnd->hwndSelf, 0, 2, es->line_height);
4376 EDIT_SetCaretPos(wnd, es, es->selection_end,
4377 es->flags & EF_AFTER_WRAP);
4378 if(!(es->style & ES_NOHIDESEL))
4379 EDIT_InvalidateText(wnd, es, es->selection_start, es->selection_end);
4380 ShowCaret(wnd->hwndSelf);
4381 EDIT_NOTIFY_PARENT(wnd, EN_SETFOCUS, "EN_SETFOCUS");
4382 }
4383
4384
4385 /*********************************************************************
4386 *
4387 * WM_SETFONT
4388 *
4389 * With Win95 look the margins are set to default font value unless
4390 * the system font (font == 0) is being set, in which case they are left
4391 * unchanged.
4392 *
4393 */
4394 static void EDIT_WM_SetFont(WND *wnd, EDITSTATE *es, HFONT font, BOOL redraw)
4395 {
4396 TEXTMETRICW tm;
4397 HDC dc;
4398 HFONT old_font = 0;
4399 RECT r;
4400
4401 es->font = font;
4402 dc = GetDC(wnd->hwndSelf);
4403 if (font)
4404 old_font = SelectObject(dc, font);
4405 GetTextMetricsW(dc, &tm);
4406 es->line_height = tm.tmHeight;
4407 es->char_width = tm.tmAveCharWidth;
4408 if (font)
4409 SelectObject(dc, old_font);
4410 ReleaseDC(wnd->hwndSelf, dc);
4411 if (font && (TWEAK_WineLook > WIN31_LOOK))
4412 EDIT_EM_SetMargins(es, EC_LEFTMARGIN | EC_RIGHTMARGIN,
4413 EC_USEFONTINFO, EC_USEFONTINFO);
4414
4415 /* Force the recalculation of the format rect for each font change */
4416 GetClientRect(wnd->hwndSelf, &r);
4417 EDIT_SetRectNP(wnd, es, &r);
4418
4419 if (es->style & ES_MULTILINE)
4420 EDIT_BuildLineDefs_ML(wnd, es);
4421 else
4422 EDIT_CalcLineWidth_SL(wnd, es);
4423
4424 if (redraw)
4425 EDIT_UpdateText(wnd, NULL, TRUE);
4426 if (es->flags & EF_FOCUSED) {
4427 DestroyCaret();
4428 CreateCaret(wnd->hwndSelf, 0, 2, es->line_height);
4429 EDIT_SetCaretPos(wnd, es, es->selection_end,
4430 es->flags & EF_AFTER_WRAP);
4431 ShowCaret(wnd->hwndSelf);
4432 }
4433 }
4434
4435
4436 /*********************************************************************
4437 *
4438 * WM_SETTEXT
4439 *
4440 * NOTES
4441 * For multiline controls (ES_MULTILINE), reception of WM_SETTEXT triggers:
4442 * The modified flag is reset. No notifications are sent.
4443 *
4444 * For single-line controls, reception of WM_SETTEXT triggers:
4445 * The modified flag is reset. EN_UPDATE and EN_CHANGE notifications are sent.
4446 *
4447 */
4448 static void EDIT_WM_SetText(WND *wnd, EDITSTATE *es, LPARAM lParam, BOOL unicode)
4449 {
4450 LPWSTR text = NULL;
4451
4452 if(unicode)
4453 text = (LPWSTR)lParam;
4454 else if (lParam)
4455 {
4456 LPCSTR textA = (LPCSTR)lParam;
4457 INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
4458 if((text = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
4459 MultiByteToWideChar(CP_ACP, 0, textA, -1, text, countW);
4460 }
4461
4462 EDIT_EM_SetSel(wnd, es, 0, (UINT)-1, FALSE);
4463 if (text) {
4464 TRACE("%s\n", debugstr_w(text));
4465 EDIT_EM_ReplaceSel(wnd, es, FALSE, text, !(es->style & ES_MULTILINE));
4466 if(!unicode)
4467 HeapFree(GetProcessHeap(), 0, text);
4468 } else {
4469 static const WCHAR empty_stringW[] = {0};
4470 TRACE("<NULL>\n");
4471 EDIT_EM_ReplaceSel(wnd, es, FALSE, empty_stringW, !(es->style & ES_MULTILINE));
4472 }
4473 es->x_offset = 0;
4474 es->flags &= ~EF_MODIFIED;
4475 EDIT_EM_SetSel(wnd, es, 0, 0, FALSE);
4476 EDIT_EM_ScrollCaret(wnd, es);
4477
4478 if (es->flags & EF_UPDATE) {
4479 es->flags &= ~EF_UPDATE;
4480 EDIT_NOTIFY_PARENT(wnd, EN_CHANGE, "EN_CHANGE");
4481 }
4482 }
4483
4484
4485 /*********************************************************************
4486 *
4487 * WM_SIZE
4488 *
4489 */
4490 static void EDIT_WM_Size(WND *wnd, EDITSTATE *es, UINT action, INT width, INT height)
4491 {
4492 if ((action == SIZE_MAXIMIZED) || (action == SIZE_RESTORED)) {
4493 RECT rc;
4494 TRACE("width = %d, height = %d\n", width, height);
4495 SetRect(&rc, 0, 0, width, height);
4496 EDIT_SetRectNP(wnd, es, &rc);
4497 EDIT_UpdateText(wnd, NULL, TRUE);
4498 }
4499 }
4500
4501
4502 /*********************************************************************
4503 *
4504 * WM_SYSKEYDOWN
4505 *
4506 */
4507 static LRESULT EDIT_WM_SysKeyDown(WND *wnd, EDITSTATE *es, INT key, DWORD key_data)
4508 {
4509 if ((key == VK_BACK) && (key_data & 0x2000)) {
4510 if (EDIT_EM_CanUndo(es))
4511 EDIT_EM_Undo(wnd, es);
4512 return 0;
4513 } else if (key == VK_UP || key == VK_DOWN) {
4514 if (EDIT_CheckCombo(wnd, es, WM_SYSKEYDOWN, key))
4515 return 0;
4516 }
4517 return DefWindowProcW(wnd->hwndSelf, WM_SYSKEYDOWN, (WPARAM)key, (LPARAM)key_data);
4518 }
4519
4520
4521 /*********************************************************************
4522 *
4523 * WM_TIMER
4524 *
4525 */
4526 static void EDIT_WM_Timer(WND *wnd, EDITSTATE *es)
4527 {
4528 if (es->region_posx < 0) {
4529 EDIT_MoveBackward(wnd, es, TRUE);
4530 } else if (es->region_posx > 0) {
4531 EDIT_MoveForward(wnd, es, TRUE);
4532 }
4533 /*
4534 * FIXME: gotta do some vertical scrolling here, like
4535 * EDIT_EM_LineScroll(wnd, 0, 1);
4536 */
4537 }
4538
4539 /*********************************************************************
4540 *
4541 * WM_VSCROLL
4542 *
4543 */
4544 static LRESULT EDIT_WM_VScroll(WND *wnd, EDITSTATE *es, INT action, INT pos)
4545 {
4546 INT dy;
4547
4548 if (!(es->style & ES_MULTILINE))
4549 return 0;
4550
4551 if (!(es->style & ES_AUTOVSCROLL))
4552 return 0;
4553
4554 dy = 0;
4555 switch (action) {
4556 case SB_LINEUP:
4557 case SB_LINEDOWN:
4558 case SB_PAGEUP:
4559 case SB_PAGEDOWN:
4560 TRACE("action %d\n", action);
4561 EDIT_EM_Scroll(wnd, es, action);
4562 return 0;
4563 case SB_TOP:
4564 TRACE("SB_TOP\n");
4565 dy = -es->y_offset;
4566 break;
4567 case SB_BOTTOM:
4568 TRACE("SB_BOTTOM\n");
4569 dy = es->line_count - 1 - es->y_offset;
4570 break;
4571 case SB_THUMBTRACK:
4572 TRACE("SB_THUMBTRACK %d\n", pos);
4573 es->flags |= EF_VSCROLL_TRACK;
4574 if(es->style & WS_VSCROLL)
4575 dy = pos - es->y_offset;
4576 else
4577 {
4578 /* Assume default scroll range 0-100 */
4579 INT vlc, new_y;
4580 /* Sanity check */
4581 if(pos < 0 || pos > 100) return 0;
4582 vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
4583 new_y = pos * (es->line_count - vlc) / 100;
4584 dy = es->line_count ? (new_y - es->y_offset) : 0;
4585 TRACE("line_count=%d, y_offset=%d, pos=%d, dy = %d\n",
4586 es->line_count, es->y_offset, pos, dy);
4587 }
4588 break;
4589 case SB_THUMBPOSITION:
4590 TRACE("SB_THUMBPOSITION %d\n", pos);
4591 es->flags &= ~EF_VSCROLL_TRACK;
4592 if(es->style & WS_VSCROLL)
4593 dy = pos - es->y_offset;
4594 else
4595 {
4596 /* Assume default scroll range 0-100 */
4597 INT vlc, new_y;
4598 /* Sanity check */
4599 if(pos < 0 || pos > 100) return 0;
4600 vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
4601 new_y = pos * (es->line_count - vlc) / 100;
4602 dy = es->line_count ? (new_y - es->y_offset) : 0;
4603 TRACE("line_count=%d, y_offset=%d, pos=%d, dy = %d\n",
4604 es->line_count, es->y_offset, pos, dy);
4605 }
4606 if (!dy)
4607 {
4608 /* force scroll info update */
4609 EDIT_UpdateScrollInfo(wnd, es);
4610 EDIT_NOTIFY_PARENT(wnd, EN_VSCROLL, "EN_VSCROLL");
4611 }
4612 break;
4613 case SB_ENDSCROLL:
4614 TRACE("SB_ENDSCROLL\n");
4615 break;
4616 /*
4617 * FIXME : the next two are undocumented !
4618 * Are we doing the right thing ?
4619 * At least Win 3.1 Notepad makes use of EM_GETTHUMB this way,
4620 * although it's also a regular control message.
4621 */
4622 case EM_GETTHUMB: /* this one is used by NT notepad */
4623 case EM_GETTHUMB16:
4624 {
4625 LRESULT ret;
4626 if(wnd->dwStyle & WS_VSCROLL)
4627 ret = GetScrollPos(wnd->hwndSelf, SB_VERT);
4628 else
4629 {
4630 /* Assume default scroll range 0-100 */
4631 INT vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
4632 ret = es->line_count ? es->y_offset * 100 / (es->line_count - vlc) : 0;
4633 }
4634 TRACE("EM_GETTHUMB: returning %ld\n", ret);
4635 return ret;
4636 }
4637 case EM_LINESCROLL16:
4638 TRACE("EM_LINESCROLL16 %d\n", pos);
4639 dy = pos;
4640 break;
4641
4642 default:
4643 ERR("undocumented WM_VSCROLL action %d (0x%04x), please report\n",
4644 action, action);
4645 return 0;
4646 }
4647 if (dy)
4648 EDIT_EM_LineScroll(wnd, es, 0, dy);
4649 return 0;
4650 }
4651
4652
4653 /*********************************************************************
4654 *
4655 * EDIT_UpdateText
4656 *
4657 */
4658 static void EDIT_UpdateText(WND *wnd, LPRECT rc, BOOL bErase)
4659 {
4660 EDITSTATE *es = *(EDITSTATE **)((wnd)->wExtra);
4661
4662 /* EF_UPDATE will be turned off in paint */
4663 if (es->flags & EF_UPDATE)
4664 EDIT_NOTIFY_PARENT(wnd, EN_UPDATE, "EN_UPDATE");
4665
4666 InvalidateRect(wnd->hwndSelf, rc, bErase);
4667 }
Windows API implementation