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