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