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