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