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