?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
user32: Fix some printf format warnings.
[wine.git] / dlls / user32 / tests / edit.c
blob89a28433544a2d9906551490eb7291b3edc2863b
1 /* Unit test suite for edit control.
2 *
3 * Copyright 2004 Vitaliy Margolen
4 * Copyright 2005 C. Scott Ananian
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <assert.h>
22 #include <windows.h>
23 #include <commctrl.h>
24
25 #include "wine/test.h"
26
27 #ifndef ES_COMBO
28 #define ES_COMBO 0x200
29 #endif
30
31 #define ID_EDITTESTDBUTTON 0x123
32 #define ID_EDITTEST2 99
33 #define MAXLEN 200
34
35 struct edit_notify {
36 int en_change, en_maxtext, en_update;
37 };
38
39 static struct edit_notify notifications;
40
41 static BOOL (WINAPI *pEndMenu) (void);
42
43 static void init_function_pointers(void)
44 {
45 HMODULE hdll = GetModuleHandleA("user32");
46
47 pEndMenu = (void*)GetProcAddress(hdll, "EndMenu");
48 }
49
50 static INT_PTR CALLBACK multi_edit_dialog_proc(HWND hdlg, UINT msg, WPARAM wparam, LPARAM lparam)
51 {
52 static int num_ok_commands = 0;
53 switch (msg)
54 {
55 case WM_INITDIALOG:
56 {
57 HWND hedit = GetDlgItem(hdlg, 1000);
58 SetFocus(hedit);
59 switch (lparam)
60 {
61 /* test cases related to bug 12319 */
62 case 0:
63 PostMessage(hedit, WM_KEYDOWN, VK_TAB, 0xf0001);
64 PostMessage(hdlg, WM_USER, 0xdeadbeef, 0);
65 break;
66 case 1:
67 PostMessage(hedit, WM_CHAR, VK_TAB, 0xf0001);
68 PostMessage(hdlg, WM_USER, 0xdeadbeef, 0);
69 break;
70 case 2:
71 PostMessage(hedit, WM_KEYDOWN, VK_TAB, 0xf0001);
72 PostMessage(hedit, WM_CHAR, VK_TAB, 0xf0001);
73 PostMessage(hdlg, WM_USER, 0xdeadbeef, 0);
74 break;
75
76 /* test cases for pressing enter */
77 case 3:
78 num_ok_commands = 0;
79 PostMessage(hedit, WM_KEYDOWN, VK_RETURN, 0x1c0001);
80 PostMessage(hdlg, WM_USER, 0xdeadbeef, 1);
81 break;
82
83 default:
84 break;
85 }
86 break;
87 }
88
89 case WM_COMMAND:
90 if (HIWORD(wparam) != BN_CLICKED)
91 break;
92
93 switch (LOWORD(wparam))
94 {
95 case IDOK:
96 num_ok_commands++;
97 break;
98
99 default:
100 break;
101 }
102 break;
103
104 case WM_USER:
105 {
106 HWND hfocus = GetFocus();
107 HWND hedit = GetDlgItem(hdlg, 1000);
108 HWND hedit2 = GetDlgItem(hdlg, 1001);
109 HWND hedit3 = GetDlgItem(hdlg, 1002);
110
111 if (wparam != 0xdeadbeef)
112 break;
113
114 switch (lparam)
115 {
116 case 0:
117 if (hfocus == hedit)
118 EndDialog(hdlg, 1111);
119 else if (hfocus == hedit2)
120 EndDialog(hdlg, 2222);
121 else if (hfocus == hedit3)
122 EndDialog(hdlg, 3333);
123 else
124 EndDialog(hdlg, 4444);
125 break;
126 case 1:
127 if ((hfocus == hedit) && (num_ok_commands == 0))
128 EndDialog(hdlg, 11);
129 else
130 EndDialog(hdlg, 22);
131 break;
132 default:
133 EndDialog(hdlg, 5555);
134 }
135 break;
136 }
137
138 case WM_CLOSE:
139 EndDialog(hdlg, 333);
140 break;
141
142 default:
143 break;
144 }
145
146 return FALSE;
147 }
148
149 static INT_PTR CALLBACK edit_dialog_proc(HWND hdlg, UINT msg, WPARAM wparam, LPARAM lparam)
150 {
151 switch (msg)
152 {
153 case WM_INITDIALOG:
154 {
155 HWND hedit = GetDlgItem(hdlg, 1000);
156 SetFocus(hedit);
157 switch (lparam)
158 {
159 /* from bug 11841 */
160 case 0:
161 PostMessage(hedit, WM_KEYDOWN, VK_ESCAPE, 0x10001);
162 break;
163 case 1:
164 PostMessage(hedit, WM_KEYDOWN, VK_RETURN, 0x1c0001);
165 break;
166 case 2:
167 PostMessage(hedit, WM_KEYDOWN, VK_TAB, 0xf0001);
168 PostMessage(hdlg, WM_USER, 0xdeadbeef, 1);
169 break;
170
171 /* more test cases for WM_CHAR */
172 case 3:
173 PostMessage(hedit, WM_CHAR, VK_ESCAPE, 0x10001);
174 PostMessage(hdlg, WM_USER, 0xdeadbeef, 0);
175 break;
176 case 4:
177 PostMessage(hedit, WM_CHAR, VK_RETURN, 0x1c0001);
178 PostMessage(hdlg, WM_USER, 0xdeadbeef, 0);
179 break;
180 case 5:
181 PostMessage(hedit, WM_CHAR, VK_TAB, 0xf0001);
182 PostMessage(hdlg, WM_USER, 0xdeadbeef, 0);
183 break;
184
185 /* more test cases for WM_KEYDOWN + WM_CHAR */
186 case 6:
187 PostMessage(hedit, WM_KEYDOWN, VK_ESCAPE, 0x10001);
188 PostMessage(hedit, WM_CHAR, VK_ESCAPE, 0x10001);
189 PostMessage(hdlg, WM_USER, 0xdeadbeef, 0);
190 break;
191 case 7:
192 PostMessage(hedit, WM_KEYDOWN, VK_RETURN, 0x1c0001);
193 PostMessage(hedit, WM_CHAR, VK_RETURN, 0x1c0001);
194 PostMessage(hdlg, WM_USER, 0xdeadbeef, 1);
195 break;
196 case 8:
197 PostMessage(hedit, WM_KEYDOWN, VK_TAB, 0xf0001);
198 PostMessage(hedit, WM_CHAR, VK_TAB, 0xf0001);
199 PostMessage(hdlg, WM_USER, 0xdeadbeef, 1);
200 break;
201
202 /* multiple tab tests */
203 case 9:
204 PostMessage(hedit, WM_KEYDOWN, VK_TAB, 0xf0001);
205 PostMessage(hedit, WM_KEYDOWN, VK_TAB, 0xf0001);
206 PostMessage(hdlg, WM_USER, 0xdeadbeef, 2);
207 break;
208 case 10:
209 PostMessage(hedit, WM_KEYDOWN, VK_TAB, 0xf0001);
210 PostMessage(hedit, WM_KEYDOWN, VK_TAB, 0xf0001);
211 PostMessage(hedit, WM_KEYDOWN, VK_TAB, 0xf0001);
212 PostMessage(hdlg, WM_USER, 0xdeadbeef, 2);
213 break;
214
215 default:
216 break;
217 }
218 break;
219 }
220
221 case WM_COMMAND:
222 if (HIWORD(wparam) != BN_CLICKED)
223 break;
224
225 switch (LOWORD(wparam))
226 {
227 case IDOK:
228 EndDialog(hdlg, 111);
229 break;
230
231 case IDCANCEL:
232 EndDialog(hdlg, 222);
233 break;
234
235 default:
236 break;
237 }
238 break;
239
240 case WM_USER:
241 {
242 int len;
243 HWND hok = GetDlgItem(hdlg, IDOK);
244 HWND hcancel = GetDlgItem(hdlg, IDCANCEL);
245 HWND hedit = GetDlgItem(hdlg, 1000);
246 HWND hfocus = GetFocus();
247
248 if (wparam != 0xdeadbeef)
249 break;
250
251 switch (lparam)
252 {
253 case 0:
254 len = SendMessage(hedit, WM_GETTEXTLENGTH, 0, 0);
255 if (len == 0)
256 EndDialog(hdlg, 444);
257 else
258 EndDialog(hdlg, 555);
259 break;
260
261 case 1:
262 len = SendMessage(hedit, WM_GETTEXTLENGTH, 0, 0);
263 if ((hfocus == hok) && len == 0)
264 EndDialog(hdlg, 444);
265 else
266 EndDialog(hdlg, 555);
267 break;
268
269 case 2:
270 if (hfocus == hok)
271 EndDialog(hdlg, 11);
272 else if (hfocus == hcancel)
273 EndDialog(hdlg, 22);
274 else if (hfocus == hedit)
275 EndDialog(hdlg, 33);
276 else
277 EndDialog(hdlg, 44);
278 break;
279
280 default:
281 EndDialog(hdlg, 555);
282 }
283 break;
284 }
285
286 case WM_CLOSE:
287 EndDialog(hdlg, 333);
288 break;
289
290 default:
291 break;
292 }
293
294 return FALSE;
295 }
296
297 static INT_PTR CALLBACK edit_singleline_dialog_proc(HWND hdlg, UINT msg, WPARAM wparam, LPARAM lparam)
298 {
299 switch (msg)
300 {
301 case WM_INITDIALOG:
302 {
303 HWND hedit = GetDlgItem(hdlg, 1000);
304 SetFocus(hedit);
305 switch (lparam)
306 {
307 /* test cases for WM_KEYDOWN */
308 case 0:
309 PostMessage(hedit, WM_KEYDOWN, VK_ESCAPE, 0x10001);
310 break;
311 case 1:
312 PostMessage(hedit, WM_KEYDOWN, VK_RETURN, 0x1c0001);
313 break;
314 case 2:
315 PostMessage(hedit, WM_KEYDOWN, VK_TAB, 0xf0001);
316 PostMessage(hdlg, WM_USER, 0xdeadbeef, 1);
317 break;
318
319 /* test cases for WM_CHAR */
320 case 3:
321 PostMessage(hedit, WM_CHAR, VK_ESCAPE, 0x10001);
322 PostMessage(hdlg, WM_USER, 0xdeadbeef, 0);
323 break;
324 case 4:
325 PostMessage(hedit, WM_CHAR, VK_RETURN, 0x1c0001);
326 PostMessage(hdlg, WM_USER, 0xdeadbeef, 0);
327 break;
328 case 5:
329 PostMessage(hedit, WM_CHAR, VK_TAB, 0xf0001);
330 PostMessage(hdlg, WM_USER, 0xdeadbeef, 0);
331 break;
332
333 /* test cases for WM_KEYDOWN + WM_CHAR */
334 case 6:
335 PostMessage(hedit, WM_KEYDOWN, VK_ESCAPE, 0x10001);
336 PostMessage(hedit, WM_CHAR, VK_ESCAPE, 0x10001);
337 break;
338 case 7:
339 PostMessage(hedit, WM_KEYDOWN, VK_RETURN, 0x1c0001);
340 PostMessage(hedit, WM_CHAR, VK_RETURN, 0x1c0001);
341 break;
342 case 8:
343 PostMessage(hedit, WM_KEYDOWN, VK_TAB, 0xf0001);
344 PostMessage(hedit, WM_CHAR, VK_TAB, 0xf0001);
345 PostMessage(hdlg, WM_USER, 0xdeadbeef, 1);
346 break;
347
348 default:
349 break;
350 }
351 break;
352 }
353
354 case WM_COMMAND:
355 if (HIWORD(wparam) != BN_CLICKED)
356 break;
357
358 switch (LOWORD(wparam))
359 {
360 case IDOK:
361 EndDialog(hdlg, 111);
362 break;
363
364 case IDCANCEL:
365 EndDialog(hdlg, 222);
366 break;
367
368 default:
369 break;
370 }
371 break;
372
373 case WM_USER:
374 {
375 HWND hok = GetDlgItem(hdlg, IDOK);
376 HWND hedit = GetDlgItem(hdlg, 1000);
377 HWND hfocus = GetFocus();
378 int len = SendMessage(hedit, WM_GETTEXTLENGTH, 0, 0);
379
380 if (wparam != 0xdeadbeef)
381 break;
382
383 switch (lparam)
384 {
385 case 0:
386 if ((hfocus == hedit) && len == 0)
387 EndDialog(hdlg, 444);
388 else
389 EndDialog(hdlg, 555);
390 break;
391
392 case 1:
393 if ((hfocus == hok) && len == 0)
394 EndDialog(hdlg, 444);
395 else
396 EndDialog(hdlg, 555);
397 break;
398
399 default:
400 EndDialog(hdlg, 55);
401 }
402 break;
403 }
404
405 case WM_CLOSE:
406 EndDialog(hdlg, 333);
407 break;
408
409 default:
410 break;
411 }
412
413 return FALSE;
414 }
415
416 static INT_PTR CALLBACK edit_wantreturn_dialog_proc(HWND hdlg, UINT msg, WPARAM wparam, LPARAM lparam)
417 {
418 switch (msg)
419 {
420 case WM_INITDIALOG:
421 {
422 HWND hedit = GetDlgItem(hdlg, 1000);
423 SetFocus(hedit);
424 switch (lparam)
425 {
426 /* test cases for WM_KEYDOWN */
427 case 0:
428 PostMessage(hedit, WM_KEYDOWN, VK_ESCAPE, 0x10001);
429 break;
430 case 1:
431 PostMessage(hedit, WM_KEYDOWN, VK_RETURN, 0x1c0001);
432 PostMessage(hdlg, WM_USER, 0xdeadbeef, 0);
433 break;
434 case 2:
435 PostMessage(hedit, WM_KEYDOWN, VK_TAB, 0xf0001);
436 PostMessage(hdlg, WM_USER, 0xdeadbeef, 1);
437 break;
438
439 /* test cases for WM_CHAR */
440 case 3:
441 PostMessage(hedit, WM_CHAR, VK_ESCAPE, 0x10001);
442 PostMessage(hdlg, WM_USER, 0xdeadbeef, 0);
443 break;
444 case 4:
445 PostMessage(hedit, WM_CHAR, VK_RETURN, 0x1c0001);
446 PostMessage(hdlg, WM_USER, 0xdeadbeef, 2);
447 break;
448 case 5:
449 PostMessage(hedit, WM_CHAR, VK_TAB, 0xf0001);
450 PostMessage(hdlg, WM_USER, 0xdeadbeef, 0);
451 break;
452
453 /* test cases for WM_KEYDOWN + WM_CHAR */
454 case 6:
455 PostMessage(hedit, WM_KEYDOWN, VK_ESCAPE, 0x10001);
456 PostMessage(hedit, WM_CHAR, VK_ESCAPE, 0x10001);
457 PostMessage(hdlg, WM_USER, 0xdeadbeef, 0);
458 break;
459 case 7:
460 PostMessage(hedit, WM_KEYDOWN, VK_RETURN, 0x1c0001);
461 PostMessage(hedit, WM_CHAR, VK_RETURN, 0x1c0001);
462 PostMessage(hdlg, WM_USER, 0xdeadbeef, 2);
463 break;
464 case 8:
465 PostMessage(hedit, WM_KEYDOWN, VK_TAB, 0xf0001);
466 PostMessage(hedit, WM_CHAR, VK_TAB, 0xf0001);
467 PostMessage(hdlg, WM_USER, 0xdeadbeef, 1);
468 break;
469
470 default:
471 break;
472 }
473 break;
474 }
475
476 case WM_COMMAND:
477 if (HIWORD(wparam) != BN_CLICKED)
478 break;
479
480 switch (LOWORD(wparam))
481 {
482 case IDOK:
483 EndDialog(hdlg, 111);
484 break;
485
486 case IDCANCEL:
487 EndDialog(hdlg, 222);
488 break;
489
490 default:
491 break;
492 }
493 break;
494
495 case WM_USER:
496 {
497 HWND hok = GetDlgItem(hdlg, IDOK);
498 HWND hedit = GetDlgItem(hdlg, 1000);
499 HWND hfocus = GetFocus();
500 int len = SendMessage(hedit, WM_GETTEXTLENGTH, 0, 0);
501
502 if (wparam != 0xdeadbeef)
503 break;
504
505 switch (lparam)
506 {
507 case 0:
508 if ((hfocus == hedit) && len == 0)
509 EndDialog(hdlg, 444);
510 else
511 EndDialog(hdlg, 555);
512 break;
513
514 case 1:
515 if ((hfocus == hok) && len == 0)
516 EndDialog(hdlg, 444);
517 else
518 EndDialog(hdlg, 555);
519 break;
520
521 case 2:
522 if ((hfocus == hedit) && len == 2)
523 EndDialog(hdlg, 444);
524 else
525 EndDialog(hdlg, 555);
526 break;
527
528 default:
529 EndDialog(hdlg, 55);
530 }
531 break;
532 }
533
534 case WM_CLOSE:
535 EndDialog(hdlg, 333);
536 break;
537
538 default:
539 break;
540 }
541
542 return FALSE;
543 }
544
545 static HINSTANCE hinst;
546 static HWND hwndET2;
547 static const char szEditTest2Class[] = "EditTest2Class";
548 static const char szEditTest3Class[] = "EditTest3Class";
549 static const char szEditTest4Class[] = "EditTest4Class";
550 static const char szEditTextPositionClass[] = "EditTextPositionWindowClass";
551
552 static HWND create_editcontrol (DWORD style, DWORD exstyle)
553 {
554 HWND handle;
555
556 handle = CreateWindowEx(exstyle,
557 "EDIT",
558 "Test Text",
559 style,
560 10, 10, 300, 300,
561 NULL, NULL, hinst, NULL);
562 ok (handle != NULL, "CreateWindow EDIT Control failed\n");
563 assert (handle);
564 if (winetest_interactive)
565 ShowWindow (handle, SW_SHOW);
566 return handle;
567 }
568
569 static HWND create_child_editcontrol (DWORD style, DWORD exstyle)
570 {
571 HWND parentWnd;
572 HWND editWnd;
573 RECT rect;
574 BOOL b;
575
576 rect.left = 0;
577 rect.top = 0;
578 rect.right = 300;
579 rect.bottom = 300;
580 b = AdjustWindowRect(&rect, WS_OVERLAPPEDWINDOW, FALSE);
581 ok(b, "AdjustWindowRect failed\n");
582
583 parentWnd = CreateWindowEx(0,
584 szEditTextPositionClass,
585 "Edit Test",
586 WS_OVERLAPPEDWINDOW,
587 CW_USEDEFAULT, CW_USEDEFAULT,
588 rect.right - rect.left, rect.bottom - rect.top,
589 NULL, NULL, hinst, NULL);
590 ok (parentWnd != NULL, "CreateWindow EDIT Test failed\n");
591 assert(parentWnd);
592
593 editWnd = CreateWindowEx(exstyle,
594 "EDIT",
595 "Test Text",
596 WS_CHILD | style,
597 0, 0, 300, 300,
598 parentWnd, NULL, hinst, NULL);
599 ok (editWnd != NULL, "CreateWindow EDIT Test Text failed\n");
600 assert(editWnd);
601 if (winetest_interactive)
602 ShowWindow (parentWnd, SW_SHOW);
603 return editWnd;
604 }
605
606 static void destroy_child_editcontrol (HWND hwndEdit)
607 {
608 if (GetParent(hwndEdit))
609 DestroyWindow(GetParent(hwndEdit));
610 else {
611 trace("Edit control has no parent!\n");
612 DestroyWindow(hwndEdit);
613 }
614 }
615
616 static LONG get_edit_style (HWND hwnd)
617 {
618 return GetWindowLongA( hwnd, GWL_STYLE ) & (
619 ES_LEFT |
620 /* FIXME: not implemented
621 ES_CENTER |
622 ES_RIGHT |
623 ES_OEMCONVERT |
624 */
625 ES_MULTILINE |
626 ES_UPPERCASE |
627 ES_LOWERCASE |
628 ES_PASSWORD |
629 ES_AUTOVSCROLL |
630 ES_AUTOHSCROLL |
631 ES_NOHIDESEL |
632 ES_COMBO |
633 ES_READONLY |
634 ES_WANTRETURN |
635 ES_NUMBER
636 );
637 }
638
639 static void set_client_height(HWND Wnd, unsigned Height)
640 {
641 RECT ClientRect, WindowRect;
642
643 GetWindowRect(Wnd, &WindowRect);
644 GetClientRect(Wnd, &ClientRect);
645 SetWindowPos(Wnd, NULL, 0, 0,
646 WindowRect.right - WindowRect.left,
647 Height + (WindowRect.bottom - WindowRect.top) -
648 (ClientRect.bottom - ClientRect.top),
649 SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER);
650
651 /* Workaround for a bug in Windows' edit control
652 (multi-line mode) */
653 GetWindowRect(Wnd, &WindowRect);
654 SetWindowPos(Wnd, NULL, 0, 0,
655 WindowRect.right - WindowRect.left + 1,
656 WindowRect.bottom - WindowRect.top + 1,
657 SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER);
658 SetWindowPos(Wnd, NULL, 0, 0,
659 WindowRect.right - WindowRect.left,
660 WindowRect.bottom - WindowRect.top,
661 SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER);
662
663 GetClientRect(Wnd, &ClientRect);
664 ok(ClientRect.bottom - ClientRect.top == Height,
665 "The client height should be %d, but is %d\n",
666 Height, ClientRect.bottom - ClientRect.top);
667 }
668
669 static void test_edit_control_1(void)
670 {
671 HWND hwEdit;
672 MSG msMessage;
673 int i;
674 LONG r;
675
676 msMessage.message = WM_KEYDOWN;
677
678 trace("EDIT: Single line\n");
679 hwEdit = create_editcontrol(ES_AUTOHSCROLL | ES_AUTOVSCROLL, 0);
680 r = get_edit_style(hwEdit);
681 ok(r == (ES_AUTOVSCROLL | ES_AUTOHSCROLL), "Wrong style expected 0xc0 got: 0x%x\n", r);
682 for (i=0;i<65535;i++)
683 {
684 msMessage.wParam = i;
685 r = SendMessage(hwEdit, WM_GETDLGCODE, 0, (LPARAM) &msMessage);
686 ok(r == (DLGC_WANTCHARS | DLGC_HASSETSEL | DLGC_WANTARROWS),
687 "Expected DLGC_WANTCHARS | DLGC_HASSETSEL | DLGC_WANTARROWS got %x\n", r);
688 }
689 DestroyWindow (hwEdit);
690
691 trace("EDIT: Single line want returns\n");
692 hwEdit = create_editcontrol(ES_WANTRETURN | ES_AUTOHSCROLL | ES_AUTOVSCROLL, 0);
693 r = get_edit_style(hwEdit);
694 ok(r == (ES_AUTOVSCROLL | ES_AUTOHSCROLL | ES_WANTRETURN), "Wrong style expected 0x10c0 got: 0x%x\n", r);
695 for (i=0;i<65535;i++)
696 {
697 msMessage.wParam = i;
698 r = SendMessage(hwEdit, WM_GETDLGCODE, 0, (LPARAM) &msMessage);
699 ok(r == (DLGC_WANTCHARS | DLGC_HASSETSEL | DLGC_WANTARROWS),
700 "Expected DLGC_WANTCHARS | DLGC_HASSETSEL | DLGC_WANTARROWS got %x\n", r);
701 }
702 DestroyWindow (hwEdit);
703
704 trace("EDIT: Multiline line\n");
705 hwEdit = create_editcontrol(ES_MULTILINE | WS_VSCROLL | ES_AUTOHSCROLL | ES_AUTOVSCROLL, 0);
706 r = get_edit_style(hwEdit);
707 ok(r == (ES_AUTOHSCROLL | ES_AUTOVSCROLL | ES_MULTILINE), "Wrong style expected 0xc4 got: 0x%x\n", r);
708 for (i=0;i<65535;i++)
709 {
710 msMessage.wParam = i;
711 r = SendMessage(hwEdit, WM_GETDLGCODE, 0, (LPARAM) &msMessage);
712 ok(r == (DLGC_WANTCHARS | DLGC_HASSETSEL | DLGC_WANTALLKEYS | DLGC_WANTARROWS),
713 "Expected DLGC_WANTCHARS | DLGC_HASSETSEL | DLGC_WANTALLKEYS | DLGC_WANTARROWS got %x\n", r);
714 }
715 DestroyWindow (hwEdit);
716
717 trace("EDIT: Multi line want returns\n");
718 hwEdit = create_editcontrol(ES_MULTILINE | WS_VSCROLL | ES_WANTRETURN | ES_AUTOHSCROLL | ES_AUTOVSCROLL, 0);
719 r = get_edit_style(hwEdit);
720 ok(r == (ES_WANTRETURN | ES_AUTOHSCROLL | ES_AUTOVSCROLL | ES_MULTILINE), "Wrong style expected 0x10c4 got: 0x%x\n", r);
721 for (i=0;i<65535;i++)
722 {
723 msMessage.wParam = i;
724 r = SendMessage(hwEdit, WM_GETDLGCODE, 0, (LPARAM) &msMessage);
725 ok(r == (DLGC_WANTCHARS | DLGC_HASSETSEL | DLGC_WANTALLKEYS | DLGC_WANTARROWS),
726 "Expected DLGC_WANTCHARS | DLGC_HASSETSEL | DLGC_WANTALLKEYS | DLGC_WANTARROWS got %x\n", r);
727 }
728 DestroyWindow (hwEdit);
729 }
730
731 /* WM_SETTEXT is implemented by selecting all text, and then replacing the
732 * selection. This test checks that the first 'select all' doesn't generate
733 * an UPDATE message which can escape and (via a handler) change the
734 * selection, which would cause WM_SETTEXT to break. This old bug
735 * was fixed 18-Mar-2005; we check here to ensure it doesn't regress.
736 */
737 static void test_edit_control_2(void)
738 {
739 HWND hwndMain, phwnd;
740 char szLocalString[MAXLEN];
741 LONG r, w = 150, h = 50;
742 POINT cpos;
743
744 /* Create main and edit windows. */
745 hwndMain = CreateWindow(szEditTest2Class, "ET2", WS_OVERLAPPEDWINDOW,
746 0, 0, 200, 200, NULL, NULL, hinst, NULL);
747 assert(hwndMain);
748 if (winetest_interactive)
749 ShowWindow (hwndMain, SW_SHOW);
750
751 hwndET2 = CreateWindow("EDIT", NULL,
752 WS_CHILD|WS_BORDER|ES_LEFT|ES_AUTOHSCROLL,
753 0, 0, w, h, /* important this not be 0 size. */
754 hwndMain, (HMENU) ID_EDITTEST2, hinst, NULL);
755 assert(hwndET2);
756 if (winetest_interactive)
757 ShowWindow (hwndET2, SW_SHOW);
758
759 trace("EDIT: SETTEXT atomicity\n");
760 /* Send messages to "type" in the word 'foo'. */
761 r = SendMessage(hwndET2, WM_CHAR, 'f', 1);
762 ok(1 == r, "Expected: %d, got: %d\n", 1, r);
763 r = SendMessage(hwndET2, WM_CHAR, 'o', 1);
764 ok(1 == r, "Expected: %d, got: %d\n", 1, r);
765 r = SendMessage(hwndET2, WM_CHAR, 'o', 1);
766 ok(1 == r, "Expected: %d, got: %d\n", 1, r);
767 /* 'foo' should have been changed to 'bar' by the UPDATE handler. */
768 GetWindowText(hwndET2, szLocalString, MAXLEN);
769 ok(lstrcmp(szLocalString, "bar")==0,
770 "Wrong contents of edit: %s\n", szLocalString);
771
772 /* try setting the caret before it's visible */
773 r = SetCaretPos(0, 0);
774 todo_wine ok(0 == r, "SetCaretPos succeeded unexpectedly, expected: 0, got: %d\n", r);
775 phwnd = SetFocus(hwndET2);
776 ok(phwnd != NULL, "SetFocus failed unexpectedly, expected non-zero, got NULL\n");
777 r = SetCaretPos(0, 0);
778 ok(1 == r, "SetCaretPos failed unexpectedly, expected: 1, got: %d\n", r);
779 r = GetCaretPos(&cpos);
780 ok(1 == r, "GetCaretPos failed unexpectedly, expected: 1, got: %d\n", r);
781 ok(cpos.x == 0 && cpos.y == 0, "Wrong caret position, expected: (0,0), got: (%d,%d)\n", cpos.x, cpos.y);
782 r = SetCaretPos(-1, -1);
783 ok(1 == r, "SetCaretPos failed unexpectedly, expected: 1, got: %d\n", r);
784 r = GetCaretPos(&cpos);
785 ok(1 == r, "GetCaretPos failed unexpectedly, expected: 1, got: %d\n", r);
786 ok(cpos.x == -1 && cpos.y == -1, "Wrong caret position, expected: (-1,-1), got: (%d,%d)\n", cpos.x, cpos.y);
787 r = SetCaretPos(w << 1, h << 1);
788 ok(1 == r, "SetCaretPos failed unexpectedly, expected: 1, got: %d\n", r);
789 r = GetCaretPos(&cpos);
790 ok(1 == r, "GetCaretPos failed unexpectedly, expected: 1, got: %d\n", r);
791 ok(cpos.x == (w << 1) && cpos.y == (h << 1), "Wrong caret position, expected: (%d,%d), got: (%d,%d)\n", w << 1, h << 1, cpos.x, cpos.y);
792 r = SetCaretPos(w, h);
793 ok(1 == r, "SetCaretPos failed unexpectedly, expected: 1, got: %d\n", r);
794 r = GetCaretPos(&cpos);
795 ok(1 == r, "GetCaretPos failed unexpectedly, expected: 1, got: %d\n", r);
796 ok(cpos.x == w && cpos.y == h, "Wrong caret position, expected: (%d,%d), got: (%d,%d)\n", w, h, cpos.x, cpos.y);
797 r = SetCaretPos(w - 1, h - 1);
798 ok(1 == r, "SetCaretPos failed unexpectedly, expected: 1, got: %d\n", r);
799 r = GetCaretPos(&cpos);
800 ok(1 == r, "GetCaretPos failed unexpectedly, expected: 1, got: %d\n", r);
801 ok(cpos.x == (w - 1) && cpos.y == (h - 1), "Wrong caret position, expected: (%d,%d), got: (%d,%d)\n", w - 1, h - 1, cpos.x, cpos.y);
802
803 /* OK, done! */
804 DestroyWindow (hwndET2);
805 DestroyWindow (hwndMain);
806 }
807
808 static void ET2_check_change(void) {
809 char szLocalString[MAXLEN];
810 /* This EN_UPDATE handler changes any 'foo' to 'bar'. */
811 GetWindowText(hwndET2, szLocalString, MAXLEN);
812 if (lstrcmp(szLocalString, "foo")==0) {
813 lstrcpy(szLocalString, "bar");
814 SendMessage(hwndET2, WM_SETTEXT, 0, (LPARAM) szLocalString);
815 }
816 /* always leave the cursor at the end. */
817 SendMessage(hwndET2, EM_SETSEL, MAXLEN - 1, MAXLEN - 1);
818 }
819 static void ET2_OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify)
820 {
821 if (id==ID_EDITTEST2 && codeNotify == EN_UPDATE)
822 ET2_check_change();
823 }
824 static LRESULT CALLBACK ET2_WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
825 {
826 switch (iMsg) {
827 case WM_COMMAND:
828 ET2_OnCommand(hwnd, LOWORD(wParam), (HWND)lParam, HIWORD(wParam));
829 break;
830 }
831 return DefWindowProc(hwnd, iMsg, wParam, lParam);
832 }
833
834 static void zero_notify(void)
835 {
836 notifications.en_change = 0;
837 notifications.en_maxtext = 0;
838 notifications.en_update = 0;
839 }
840
841 #define test_notify(enchange, enmaxtext, enupdate) \
842 ok(notifications.en_change == enchange, "expected %d EN_CHANGE notifications, " \
843 "got %d\n", enchange, notifications.en_change); \
844 ok(notifications.en_maxtext == enmaxtext, "expected %d EN_MAXTEXT notifications, " \
845 "got %d\n", enmaxtext, notifications.en_maxtext); \
846 ok(notifications.en_update == enupdate, "expected %d EN_UPDATE notifications, " \
847 "got %d\n", enupdate, notifications.en_update)
848
849
850 static LRESULT CALLBACK edit3_wnd_procA(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
851 {
852 switch (msg) {
853 case WM_COMMAND:
854 switch (HIWORD(wParam)) {
855 case EN_MAXTEXT:
856 notifications.en_maxtext++;
857 break;
858 case EN_UPDATE:
859 notifications.en_update++;
860 break;
861 case EN_CHANGE:
862 notifications.en_change++;
863 break;
864 }
865 break;
866 }
867 return DefWindowProcA(hWnd, msg, wParam, lParam);
868 }
869
870 /* Test behaviour of WM_SETTEXT, WM_REPLACESEL and notificatisons sent in response
871 * to these messages.
872 */
873 static void test_edit_control_3(void)
874 {
875 HWND hWnd;
876 HWND hParent;
877 HDC hDC;
878 int len, dpi;
879 static const char *str = "this is a long string.";
880 static const char *str2 = "this is a long string.\r\nthis is a long string.\r\nthis is a long string.\r\nthis is a long string.";
881
882 hDC = GetDC(NULL);
883 dpi = GetDeviceCaps(hDC, LOGPIXELSY);
884 ReleaseDC(NULL, hDC);
885
886 trace("EDIT: Test notifications\n");
887
888 hParent = CreateWindowExA(0,
889 szEditTest3Class,
890 NULL,
891 0,
892 CW_USEDEFAULT, CW_USEDEFAULT, 10, 10,
893 NULL, NULL, NULL, NULL);
894 assert(hParent);
895
896 trace("EDIT: Single line, no ES_AUTOHSCROLL\n");
897 hWnd = CreateWindowExA(0,
898 "EDIT",
899 NULL,
900 0,
901 10, 10, 50, 50,
902 hParent, NULL, NULL, NULL);
903 assert(hWnd);
904
905 zero_notify();
906 SendMessageA(hWnd, EM_REPLACESEL, 0, (LPARAM)str);
907 len = SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
908 ok(lstrlenA(str) > len, "text should have been truncated\n");
909 test_notify(1, 1, 1);
910
911 SendMessageA(hWnd, WM_SETTEXT, 0, (LPARAM)"");
912 zero_notify();
913 SendMessageA(hWnd, EM_REPLACESEL, 0, (LPARAM)"a");
914 len = SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
915 ok(1 == len, "wrong text length, expected 1, got %d\n", len);
916 test_notify(1, 0, 1);
917
918 zero_notify();
919 SendMessageA(hWnd, WM_SETTEXT, 0, (LPARAM)str);
920 len = SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
921 ok(lstrlenA(str) == len, "text shouldn't have been truncated\n");
922 test_notify(1, 0, 1);
923
924 len = SendMessageA(hWnd, EM_GETSEL, 0, 0);
925 ok(LOWORD(len)==0, "Unexpected start position for selection %d\n", LOWORD(len));
926 ok(HIWORD(len)==0, "Unexpected end position for selection %d\n", HIWORD(len));
927 SendMessage(hParent, WM_SETFOCUS, 0, (LPARAM)hWnd);
928 len = SendMessageA(hWnd, EM_GETSEL, 0, 0);
929 ok(LOWORD(len)==0, "Unexpected start position for selection %d\n", LOWORD(len));
930 ok(HIWORD(len)==0, "Unexpected end position for selection %d\n", HIWORD(len));
931
932 SendMessageA(hWnd, EM_SETLIMITTEXT, 5, 0);
933
934 SendMessageA(hWnd, WM_SETTEXT, 0, (LPARAM)"");
935 zero_notify();
936 SendMessageA(hWnd, EM_REPLACESEL, 0, (LPARAM)str);
937 len = SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
938 ok(5 == len, "text should have been truncated to limit, expected 5, got %d\n", len);
939 test_notify(1, 1, 1);
940
941 zero_notify();
942 SendMessageA(hWnd, WM_SETTEXT, 0, (LPARAM)str);
943 len = SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
944 ok(lstrlenA(str) == len, "text shouldn't have been truncated\n");
945 test_notify(1, 0, 1);
946
947 DestroyWindow(hWnd);
948
949 trace("EDIT: Single line, ES_AUTOHSCROLL\n");
950 hWnd = CreateWindowExA(0,
951 "EDIT",
952 NULL,
953 ES_AUTOHSCROLL,
954 10, 10, 50, 50,
955 hParent, NULL, NULL, NULL);
956 assert(hWnd);
957
958 zero_notify();
959 SendMessageA(hWnd, EM_REPLACESEL, 0, (LPARAM)str);
960 len = SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
961 ok(lstrlenA(str) == len, "text shouldn't have been truncated\n");
962 test_notify(1, 0, 1);
963
964 zero_notify();
965 SendMessageA(hWnd, WM_SETTEXT, 0, (LPARAM)str);
966 len = SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
967 ok(lstrlenA(str) == len, "text shouldn't have been truncated\n");
968 test_notify(1, 0, 1);
969
970 SendMessageA(hWnd, EM_SETLIMITTEXT, 5, 0);
971
972 SendMessageA(hWnd, WM_SETTEXT, 0, (LPARAM)"");
973 zero_notify();
974 SendMessageA(hWnd, EM_REPLACESEL, 0, (LPARAM)str);
975 len = SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
976 ok(5 == len, "text should have been truncated to limit, expected 5, got %d\n", len);
977 test_notify(1, 1, 1);
978
979 zero_notify();
980 SendMessageA(hWnd, WM_SETTEXT, 0, (LPARAM)str);
981 len = SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
982 ok(lstrlenA(str) == len, "text shouldn't have been truncated\n");
983 test_notify(1, 0, 1);
984
985 DestroyWindow(hWnd);
986
987 trace("EDIT: Multline, no ES_AUTOHSCROLL, no ES_AUTOVSCROLL\n");
988 hWnd = CreateWindowExA(0,
989 "EDIT",
990 NULL,
991 ES_MULTILINE,
992 10, 10, (50 * dpi) / 96, (50 * dpi) / 96,
993 hParent, NULL, NULL, NULL);
994 assert(hWnd);
995
996 zero_notify();
997 SendMessageA(hWnd, EM_REPLACESEL, 0, (LPARAM)str);
998 len = SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
999 ok(0 == len, "text should have been truncated, expected 0, got %d\n", len);
1000 test_notify(1, 1, 1);
1001
1002 SendMessageA(hWnd, WM_SETTEXT, 0, (LPARAM)"");
1003 zero_notify();
1004 SendMessageA(hWnd, EM_REPLACESEL, 0, (LPARAM)"a");
1005 len = SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
1006 ok(1 == SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0), "wrong text length, expected 1, got %d\n", len);
1007 test_notify(1, 0, 1);
1008
1009 zero_notify();
1010 SendMessageA(hWnd, WM_SETTEXT, 0, (LPARAM)str);
1011 len = SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
1012 ok(lstrlenA(str) == len, "text shouldn't have been truncated\n");
1013 test_notify(0, 0, 0);
1014
1015 SendMessageA(hWnd, EM_SETLIMITTEXT, 5, 0);
1016
1017 SendMessageA(hWnd, WM_SETTEXT, 0, (LPARAM)"");
1018 zero_notify();
1019 SendMessageA(hWnd, EM_REPLACESEL, 0, (LPARAM)str);
1020 len = SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
1021 ok(5 == len, "text should have been truncated to limit, expected 5, got %d\n", len);
1022 test_notify(1, 1, 1);
1023
1024 zero_notify();
1025 SendMessageA(hWnd, WM_SETTEXT, 0, (LPARAM)str);
1026 len = SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
1027 ok(lstrlenA(str) == len, "text shouldn't have been truncated\n");
1028 test_notify(0, 0, 0);
1029
1030 DestroyWindow(hWnd);
1031
1032 trace("EDIT: Multline, ES_AUTOHSCROLL, no ES_AUTOVSCROLL\n");
1033 hWnd = CreateWindowExA(0,
1034 "EDIT",
1035 NULL,
1036 ES_MULTILINE | ES_AUTOHSCROLL,
1037 10, 10, (50 * dpi) / 96, (50 * dpi) / 96,
1038 hParent, NULL, NULL, NULL);
1039 assert(hWnd);
1040
1041 zero_notify();
1042 SendMessageA(hWnd, EM_REPLACESEL, 0, (LPARAM)str2);
1043 len = SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
1044 ok(0 == len, "text should have been truncated, expected 0, got %d\n", len);
1045 test_notify(1, 1, 1);
1046
1047 SendMessageA(hWnd, WM_SETTEXT, 0, (LPARAM)"");
1048 zero_notify();
1049 SendMessageA(hWnd, EM_REPLACESEL, 0, (LPARAM)"a");
1050 len = SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
1051 ok(1 == SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0), "wrong text length, expected 1, got %d\n", len);
1052 test_notify(1, 0, 1);
1053
1054 zero_notify();
1055 SendMessageA(hWnd, WM_SETTEXT, 0, (LPARAM)str2);
1056 len = SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
1057 ok(lstrlenA(str2) == len, "text shouldn't have been truncated\n");
1058 test_notify(0, 0, 0);
1059
1060 SendMessageA(hWnd, EM_SETLIMITTEXT, 5, 0);
1061
1062 SendMessageA(hWnd, WM_SETTEXT, 0, (LPARAM)"");
1063 zero_notify();
1064 SendMessageA(hWnd, EM_REPLACESEL, 0, (LPARAM)str2);
1065 len = SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
1066 ok(5 == len, "text should have been truncated to limit, expected 5, got %d\n", len);
1067 test_notify(1, 1, 1);
1068
1069 zero_notify();
1070 SendMessageA(hWnd, WM_SETTEXT, 0, (LPARAM)str2);
1071 len = SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
1072 ok(lstrlenA(str2) == len, "text shouldn't have been truncated\n");
1073 test_notify(0, 0, 0);
1074
1075 DestroyWindow(hWnd);
1076
1077 trace("EDIT: Multline, ES_AUTOHSCROLL and ES_AUTOVSCROLL\n");
1078 hWnd = CreateWindowExA(0,
1079 "EDIT",
1080 NULL,
1081 ES_MULTILINE | ES_AUTOHSCROLL | ES_AUTOVSCROLL,
1082 10, 10, 50, 50,
1083 hParent, NULL, NULL, NULL);
1084 assert(hWnd);
1085
1086 zero_notify();
1087 SendMessageA(hWnd, EM_REPLACESEL, 0, (LPARAM)str2);
1088 len = SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
1089 ok(lstrlenA(str2) == len, "text shouldn't have been truncated\n");
1090 test_notify(1, 0, 1);
1091
1092 zero_notify();
1093 SendMessageA(hWnd, WM_SETTEXT, 0, (LPARAM)str2);
1094 len = SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
1095 ok(lstrlenA(str2) == len, "text shouldn't have been truncated\n");
1096 test_notify(0, 0, 0);
1097
1098 SendMessageA(hWnd, EM_SETLIMITTEXT, 5, 0);
1099
1100 SendMessageA(hWnd, WM_SETTEXT, 0, (LPARAM)"");
1101 zero_notify();
1102 SendMessageA(hWnd, EM_REPLACESEL, 0, (LPARAM)str2);
1103 len = SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
1104 ok(5 == len, "text should have been truncated to limit, expected 5, got %d\n", len);
1105 test_notify(1, 1, 1);
1106
1107 zero_notify();
1108 SendMessageA(hWnd, WM_SETTEXT, 0, (LPARAM)str2);
1109 len = SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
1110 ok(lstrlenA(str2) == len, "text shouldn't have been truncated\n");
1111 test_notify(0, 0, 0);
1112
1113 DestroyWindow(hWnd);
1114 }
1115
1116 /* Test EM_CHARFROMPOS and EM_POSFROMCHAR
1117 */
1118 static void test_edit_control_4(void)
1119 {
1120 HWND hwEdit;
1121 int lo, hi, mid;
1122 int ret;
1123 int i;
1124
1125 trace("EDIT: Test EM_CHARFROMPOS and EM_POSFROMCHAR\n");
1126 hwEdit = create_editcontrol(ES_AUTOHSCROLL | ES_AUTOVSCROLL, 0);
1127 SendMessage(hwEdit, WM_SETTEXT, 0, (LPARAM) "aa");
1128 lo = LOWORD(SendMessage(hwEdit, EM_POSFROMCHAR, 0, 0));
1129 hi = LOWORD(SendMessage(hwEdit, EM_POSFROMCHAR, 1, 0));
1130 mid = lo + (hi - lo) / 2;
1131
1132 for (i = lo; i < mid; i++) {
1133 ret = LOWORD(SendMessage(hwEdit, EM_CHARFROMPOS, 0, i));
1134 ok(0 == ret, "expected 0 got %d\n", ret);
1135 }
1136 for (i = mid; i <= hi; i++) {
1137 ret = LOWORD(SendMessage(hwEdit, EM_CHARFROMPOS, 0, i));
1138 ok(1 == ret, "expected 1 got %d\n", ret);
1139 }
1140 ret = SendMessage(hwEdit, EM_POSFROMCHAR, 2, 0);
1141 ok(-1 == ret, "expected -1 got %d\n", ret);
1142 DestroyWindow(hwEdit);
1143
1144 hwEdit = create_editcontrol(ES_RIGHT | ES_AUTOHSCROLL | ES_AUTOVSCROLL, 0);
1145 SendMessage(hwEdit, WM_SETTEXT, 0, (LPARAM) "aa");
1146 lo = LOWORD(SendMessage(hwEdit, EM_POSFROMCHAR, 0, 0));
1147 hi = LOWORD(SendMessage(hwEdit, EM_POSFROMCHAR, 1, 0));
1148 mid = lo + (hi - lo) / 2;
1149
1150 for (i = lo; i < mid; i++) {
1151 ret = LOWORD(SendMessage(hwEdit, EM_CHARFROMPOS, 0, i));
1152 ok(0 == ret, "expected 0 got %d\n", ret);
1153 }
1154 for (i = mid; i <= hi; i++) {
1155 ret = LOWORD(SendMessage(hwEdit, EM_CHARFROMPOS, 0, i));
1156 ok(1 == ret, "expected 1 got %d\n", ret);
1157 }
1158 ret = SendMessage(hwEdit, EM_POSFROMCHAR, 2, 0);
1159 ok(-1 == ret, "expected -1 got %d\n", ret);
1160 DestroyWindow(hwEdit);
1161
1162 hwEdit = create_editcontrol(ES_CENTER | ES_AUTOHSCROLL | ES_AUTOVSCROLL, 0);
1163 SendMessage(hwEdit, WM_SETTEXT, 0, (LPARAM) "aa");
1164 lo = LOWORD(SendMessage(hwEdit, EM_POSFROMCHAR, 0, 0));
1165 hi = LOWORD(SendMessage(hwEdit, EM_POSFROMCHAR, 1, 0));
1166 mid = lo + (hi - lo) / 2;
1167
1168 for (i = lo; i < mid; i++) {
1169 ret = LOWORD(SendMessage(hwEdit, EM_CHARFROMPOS, 0, i));
1170 ok(0 == ret, "expected 0 got %d\n", ret);
1171 }
1172 for (i = mid; i <= hi; i++) {
1173 ret = LOWORD(SendMessage(hwEdit, EM_CHARFROMPOS, 0, i));
1174 ok(1 == ret, "expected 1 got %d\n", ret);
1175 }
1176 ret = SendMessage(hwEdit, EM_POSFROMCHAR, 2, 0);
1177 ok(-1 == ret, "expected -1 got %d\n", ret);
1178 DestroyWindow(hwEdit);
1179
1180 hwEdit = create_editcontrol(ES_MULTILINE | ES_AUTOHSCROLL | ES_AUTOVSCROLL, 0);
1181 SendMessage(hwEdit, WM_SETTEXT, 0, (LPARAM) "aa");
1182 lo = LOWORD(SendMessage(hwEdit, EM_POSFROMCHAR, 0, 0));
1183 hi = LOWORD(SendMessage(hwEdit, EM_POSFROMCHAR, 1, 0));
1184 mid = lo + (hi - lo) / 2 +1;
1185
1186 for (i = lo; i < mid; i++) {
1187 ret = LOWORD(SendMessage(hwEdit, EM_CHARFROMPOS, 0, i));
1188 ok((0 == ret || 1 == ret /* Vista */), "expected 0 or 1 got %d\n", ret);
1189 }
1190 for (i = mid; i <= hi; i++) {
1191 ret = LOWORD(SendMessage(hwEdit, EM_CHARFROMPOS, 0, i));
1192 ok(1 == ret, "expected 1 got %d\n", ret);
1193 }
1194 ret = SendMessage(hwEdit, EM_POSFROMCHAR, 2, 0);
1195 ok(-1 == ret, "expected -1 got %d\n", ret);
1196 DestroyWindow(hwEdit);
1197
1198 hwEdit = create_editcontrol(ES_MULTILINE | ES_RIGHT | ES_AUTOHSCROLL | ES_AUTOVSCROLL, 0);
1199 SendMessage(hwEdit, WM_SETTEXT, 0, (LPARAM) "aa");
1200 lo = LOWORD(SendMessage(hwEdit, EM_POSFROMCHAR, 0, 0));
1201 hi = LOWORD(SendMessage(hwEdit, EM_POSFROMCHAR, 1, 0));
1202 mid = lo + (hi - lo) / 2 +1;
1203
1204 for (i = lo; i < mid; i++) {
1205 ret = LOWORD(SendMessage(hwEdit, EM_CHARFROMPOS, 0, i));
1206 ok((0 == ret || 1 == ret /* Vista */), "expected 0 or 1 got %d\n", ret);
1207 }
1208 for (i = mid; i <= hi; i++) {
1209 ret = LOWORD(SendMessage(hwEdit, EM_CHARFROMPOS, 0, i));
1210 ok(1 == ret, "expected 1 got %d\n", ret);
1211 }
1212 ret = SendMessage(hwEdit, EM_POSFROMCHAR, 2, 0);
1213 ok(-1 == ret, "expected -1 got %d\n", ret);
1214 DestroyWindow(hwEdit);
1215
1216 hwEdit = create_editcontrol(ES_MULTILINE | ES_CENTER | ES_AUTOHSCROLL | ES_AUTOVSCROLL, 0);
1217 SendMessage(hwEdit, WM_SETTEXT, 0, (LPARAM) "aa");
1218 lo = LOWORD(SendMessage(hwEdit, EM_POSFROMCHAR, 0, 0));
1219 hi = LOWORD(SendMessage(hwEdit, EM_POSFROMCHAR, 1, 0));
1220 mid = lo + (hi - lo) / 2 +1;
1221
1222 for (i = lo; i < mid; i++) {
1223 ret = LOWORD(SendMessage(hwEdit, EM_CHARFROMPOS, 0, i));
1224 ok((0 == ret || 1 == ret /* Vista */), "expected 0 or 1 got %d\n", ret);
1225 }
1226 for (i = mid; i <= hi; i++) {
1227 ret = LOWORD(SendMessage(hwEdit, EM_CHARFROMPOS, 0, i));
1228 ok(1 == ret, "expected 1 got %d\n", ret);
1229 }
1230 ret = SendMessage(hwEdit, EM_POSFROMCHAR, 2, 0);
1231 ok(-1 == ret, "expected -1 got %d\n", ret);
1232 DestroyWindow(hwEdit);
1233 }
1234
1235 /* Test if creating edit control without ES_AUTOHSCROLL and ES_AUTOVSCROLL
1236 * truncates text that doesn't fit.
1237 */
1238 static void test_edit_control_5(void)
1239 {
1240 static const char *str = "test\r\ntest";
1241 HWND parentWnd;
1242 HWND hWnd;
1243 int len;
1244 RECT rc1 = { 10, 10, 11, 11};
1245 RECT rc;
1246
1247 /* first show that a non-child won't do for this test */
1248 hWnd = CreateWindowEx(0,
1249 "EDIT",
1250 str,
1251 0,
1252 10, 10, 1, 1,
1253 NULL, NULL, NULL, NULL);
1254 assert(hWnd);
1255 /* size of non-child edit control is (much) bigger than requested */
1256 GetWindowRect( hWnd, &rc);
1257 ok( rc.right - rc.left > 20, "size of the window (%d) is smaller than expected\n",
1258 rc.right - rc.left);
1259 DestroyWindow(hWnd);
1260 /* so create a parent, and give it edit controls children to test with */
1261 parentWnd = CreateWindowEx(0,
1262 szEditTextPositionClass,
1263 "Edit Test", WS_VISIBLE |
1264 WS_OVERLAPPEDWINDOW,
1265 CW_USEDEFAULT, CW_USEDEFAULT,
1266 250, 250,
1267 NULL, NULL, hinst, NULL);
1268 assert(parentWnd);
1269 ShowWindow( parentWnd, SW_SHOW);
1270 /* single line */
1271 hWnd = CreateWindowEx(0,
1272 "EDIT",
1273 str, WS_VISIBLE | WS_BORDER |
1274 WS_CHILD,
1275 rc1.left, rc1.top, rc1.right - rc1.left, rc1.bottom - rc1.top,
1276 parentWnd, NULL, NULL, NULL);
1277 assert(hWnd);
1278 GetClientRect( hWnd, &rc);
1279 ok( rc.right == rc1.right - rc1.left && rc.bottom == rc1.bottom - rc1.top,
1280 "Client rectangle not the expected size (%d,%d,%d,%d)\n",
1281 rc.left, rc.top, rc.right, rc.bottom);
1282 len = SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
1283 ok(lstrlenA(str) == len, "text shouldn't have been truncated\n");
1284 DestroyWindow(hWnd);
1285 /* multi line */
1286 hWnd = CreateWindowEx(0,
1287 "EDIT",
1288 str,
1289 WS_CHILD | ES_MULTILINE,
1290 rc1.left, rc1.top, rc1.right - rc1.left, rc1.bottom - rc1.top,
1291 parentWnd, NULL, NULL, NULL);
1292 assert(hWnd);
1293 GetClientRect( hWnd, &rc);
1294 ok( rc.right == rc1.right - rc1.left && rc.bottom == rc1.bottom - rc1.top,
1295 "Client rectangle not the expected size (%d,%d,%d,%d)\n",
1296 rc.left, rc.top, rc.right, rc.bottom);
1297 len = SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
1298 ok(lstrlenA(str) == len, "text shouldn't have been truncated\n");
1299 DestroyWindow(hWnd);
1300 }
1301
1302 /* Test WM_GETTEXT processing
1303 * after destroy messages
1304 */
1305 static void test_edit_control_6(void)
1306 {
1307 static const char *str = "test\r\ntest";
1308 char buf[MAXLEN];
1309 LONG ret;
1310 HWND hWnd;
1311
1312 hWnd = CreateWindowEx(0,
1313 "EDIT",
1314 "Test",
1315 0,
1316 10, 10, 1, 1,
1317 NULL, NULL, hinst, NULL);
1318 assert(hWnd);
1319
1320 ret = SendMessageA(hWnd, WM_SETTEXT, 0, (LPARAM)str);
1321 ok(ret == TRUE, "Expected %d, got %d\n", TRUE, ret);
1322 ret = SendMessageA(hWnd, WM_GETTEXT, MAXLEN, (LPARAM)buf);
1323 ok(ret == lstrlen(str), "Expected %s, got len %d\n", str, ret);
1324 ok(!lstrcmp(buf, str), "Expected %s, got %s\n", str, buf);
1325 buf[0] = 0;
1326 ret = SendMessageA(hWnd, WM_DESTROY, 0, 0);
1327 ok(ret == 0, "Expected 0, got %d\n", ret);
1328 ret = SendMessageA(hWnd, WM_GETTEXT, MAXLEN, (LPARAM)buf);
1329 ok(ret == lstrlen(str), "Expected %s, got len %d\n", str, ret);
1330 ok(!lstrcmp(buf, str), "Expected %s, got %s\n", str, buf);
1331 buf[0] = 0;
1332 ret = SendMessageA(hWnd, WM_NCDESTROY, 0, 0);
1333 ok(ret == 0, "Expected 0, got %d\n", ret);
1334 ret = SendMessageA(hWnd, WM_GETTEXT, MAXLEN, (LPARAM)buf);
1335 ok(ret == 0, "Expected 0, got len %d\n", ret);
1336 ok(!lstrcmp(buf, ""), "Expected empty string, got %s\n", buf);
1337
1338 DestroyWindow(hWnd);
1339 }
1340
1341 static void test_edit_control_limittext(void)
1342 {
1343 HWND hwEdit;
1344 DWORD r;
1345
1346 /* Test default limit for single-line control */
1347 trace("EDIT: buffer limit for single-line\n");
1348 hwEdit = create_editcontrol(ES_AUTOHSCROLL | ES_AUTOVSCROLL, 0);
1349 r = SendMessage(hwEdit, EM_GETLIMITTEXT, 0, 0);
1350 ok(r == 30000, "Incorrect default text limit, expected 30000 got %u\n", r);
1351 SendMessage(hwEdit, EM_SETLIMITTEXT, 0, 0);
1352 r = SendMessage(hwEdit, EM_GETLIMITTEXT, 0, 0);
1353 ok( r == 2147483646, "got limit %u (expected 2147483646)\n", r);
1354 DestroyWindow(hwEdit);
1355
1356 /* Test default limit for multi-line control */
1357 trace("EDIT: buffer limit for multi-line\n");
1358 hwEdit = create_editcontrol(ES_MULTILINE | WS_VSCROLL | ES_AUTOHSCROLL | ES_AUTOVSCROLL, 0);
1359 r = SendMessage(hwEdit, EM_GETLIMITTEXT, 0, 0);
1360 ok(r == 30000, "Incorrect default text limit, expected 30000 got %u\n", r);
1361 SendMessage(hwEdit, EM_SETLIMITTEXT, 0, 0);
1362 r = SendMessage(hwEdit, EM_GETLIMITTEXT, 0, 0);
1363 ok( r == 4294967295U, "got limit %u (expected 4294967295)\n", r);
1364 DestroyWindow(hwEdit);
1365 }
1366
1367 /* Test EM_SCROLL */
1368 static void test_edit_control_scroll(void)
1369 {
1370 static const char *single_line_str = "a";
1371 static const char *multiline_str = "Test\r\nText";
1372 HWND hwEdit;
1373 LONG ret;
1374
1375 /* Check the return value when EM_SCROLL doesn't scroll
1376 * anything. Should not return true unless any lines were actually
1377 * scrolled. */
1378 hwEdit = CreateWindow(
1379 "EDIT",
1380 single_line_str,
1381 WS_VSCROLL | ES_MULTILINE,
1382 1, 1, 100, 100,
1383 NULL, NULL, hinst, NULL);
1384
1385 assert(hwEdit);
1386
1387 ret = SendMessage(hwEdit, EM_SCROLL, SB_PAGEDOWN, 0);
1388 ok(!ret, "Returned %x, expected 0.\n", ret);
1389
1390 ret = SendMessage(hwEdit, EM_SCROLL, SB_PAGEUP, 0);
1391 ok(!ret, "Returned %x, expected 0.\n", ret);
1392
1393 ret = SendMessage(hwEdit, EM_SCROLL, SB_LINEUP, 0);
1394 ok(!ret, "Returned %x, expected 0.\n", ret);
1395
1396 ret = SendMessage(hwEdit, EM_SCROLL, SB_LINEDOWN, 0);
1397 ok(!ret, "Returned %x, expected 0.\n", ret);
1398
1399 DestroyWindow (hwEdit);
1400
1401 /* SB_PAGEDOWN while at the beginning of a buffer with few lines
1402 should not cause EM_SCROLL to return a negative value of
1403 scrolled lines that would put us "before" the beginning. */
1404 hwEdit = CreateWindow(
1405 "EDIT",
1406 multiline_str,
1407 WS_VSCROLL | ES_MULTILINE,
1408 0, 0, 100, 100,
1409 NULL, NULL, hinst, NULL);
1410 assert(hwEdit);
1411
1412 ret = SendMessage(hwEdit, EM_SCROLL, SB_PAGEDOWN, 0);
1413 ok(!ret, "Returned %x, expected 0.\n", ret);
1414
1415 DestroyWindow (hwEdit);
1416 }
1417
1418 static void test_margins(void)
1419 {
1420 HWND hwEdit;
1421 RECT old_rect, new_rect;
1422 INT old_right_margin;
1423 DWORD old_margins, new_margins;
1424
1425 hwEdit = create_editcontrol(WS_BORDER | ES_AUTOHSCROLL | ES_AUTOVSCROLL, 0);
1426
1427 old_margins = SendMessage(hwEdit, EM_GETMARGINS, 0, 0);
1428 old_right_margin = HIWORD(old_margins);
1429
1430 /* Check if setting the margins works */
1431
1432 SendMessage(hwEdit, EM_SETMARGINS, EC_LEFTMARGIN, MAKELONG(10, 0));
1433 new_margins = SendMessage(hwEdit, EM_GETMARGINS, 0, 0);
1434 ok(LOWORD(new_margins) == 10, "Wrong left margin: %d\n", LOWORD(new_margins));
1435 ok(HIWORD(new_margins) == old_right_margin, "Wrong right margin: %d\n", HIWORD(new_margins));
1436
1437 SendMessage(hwEdit, EM_SETMARGINS, EC_RIGHTMARGIN, MAKELONG(0, 10));
1438 new_margins = SendMessage(hwEdit, EM_GETMARGINS, 0, 0);
1439 ok(LOWORD(new_margins) == 10, "Wrong left margin: %d\n", LOWORD(new_margins));
1440 ok(HIWORD(new_margins) == 10, "Wrong right margin: %d\n", HIWORD(new_margins));
1441
1442
1443 /* The size of the rectangle must decrease if we increase the margin */
1444
1445 SendMessage(hwEdit, EM_SETMARGINS, EC_LEFTMARGIN | EC_RIGHTMARGIN, MAKELONG(5, 5));
1446 SendMessage(hwEdit, EM_GETRECT, 0, (LPARAM)&old_rect);
1447 SendMessage(hwEdit, EM_SETMARGINS, EC_LEFTMARGIN | EC_RIGHTMARGIN, MAKELONG(15, 20));
1448 SendMessage(hwEdit, EM_GETRECT, 0, (LPARAM)&new_rect);
1449 ok(new_rect.left == old_rect.left + 10, "The left border of the rectangle is wrong\n");
1450 ok(new_rect.right == old_rect.right - 15, "The right border of the rectangle is wrong\n");
1451 ok(new_rect.top == old_rect.top, "The top border of the rectangle must not change\n");
1452 ok(new_rect.bottom == old_rect.bottom, "The bottom border of the rectangle must not change\n");
1453
1454
1455 /* If we set the margin to same value as the current margin,
1456 the rectangle must not change */
1457
1458 SendMessage(hwEdit, EM_SETMARGINS, EC_LEFTMARGIN | EC_RIGHTMARGIN, MAKELONG(10, 10));
1459 old_rect.left = 1;
1460 old_rect.right = 99;
1461 old_rect.top = 1;
1462 old_rect.bottom = 99;
1463 SendMessage(hwEdit, EM_SETRECT, 0, (LPARAM)&old_rect);
1464 SendMessage(hwEdit, EM_GETRECT, 0, (LPARAM)&old_rect);
1465 SendMessage(hwEdit, EM_SETMARGINS, EC_LEFTMARGIN | EC_RIGHTMARGIN, MAKELONG(10, 10));
1466 SendMessage(hwEdit, EM_GETRECT, 0, (LPARAM)&new_rect);
1467 ok(new_rect.left == old_rect.left, "The left border of the rectangle has changed\n");
1468 ok(new_rect.right == old_rect.right, "The right border of the rectangle has changed\n");
1469 ok(new_rect.top == old_rect.top, "The top border of the rectangle has changed\n");
1470 ok(new_rect.bottom == old_rect.bottom, "The bottom border of the rectangle has changed\n");
1471
1472 DestroyWindow (hwEdit);
1473 }
1474
1475 static INT CALLBACK find_font_proc(const LOGFONT *elf, const TEXTMETRIC *ntm, DWORD type, LPARAM lParam)
1476 {
1477 return 0;
1478 }
1479
1480 static void test_margins_font_change(void)
1481 {
1482 HWND hwEdit;
1483 DWORD margins, font_margins;
1484 LOGFONT lf;
1485 HFONT hfont, hfont2;
1486 HDC hdc = GetDC(0);
1487
1488 if(EnumFontFamiliesA(hdc, "Arial", find_font_proc, 0))
1489 {
1490 trace("Arial not found - skipping font change margin tests\n");
1491 ReleaseDC(0, hdc);
1492 return;
1493 }
1494 ReleaseDC(0, hdc);
1495
1496 hwEdit = create_child_editcontrol(0, 0);
1497
1498 SetWindowPos(hwEdit, NULL, 10, 10, 1000, 100, SWP_NOZORDER | SWP_NOACTIVATE);
1499
1500 memset(&lf, 0, sizeof(lf));
1501 strcpy(lf.lfFaceName, "Arial");
1502 lf.lfHeight = 16;
1503 lf.lfCharSet = DEFAULT_CHARSET;
1504 hfont = CreateFontIndirectA(&lf);
1505 lf.lfHeight = 30;
1506 hfont2 = CreateFontIndirectA(&lf);
1507
1508 SendMessageA(hwEdit, WM_SETFONT, (WPARAM)hfont, 0);
1509 font_margins = SendMessage(hwEdit, EM_GETMARGINS, 0, 0);
1510 ok(LOWORD(font_margins) != 0, "got %d\n", LOWORD(font_margins));
1511 ok(HIWORD(font_margins) != 0, "got %d\n", HIWORD(font_margins));
1512
1513 /* With 'small' edit controls, test that the margin doesn't get set */
1514 SetWindowPos(hwEdit, NULL, 10, 10, 16, 100, SWP_NOZORDER | SWP_NOACTIVATE);
1515 SendMessageA(hwEdit, EM_SETMARGINS, EC_LEFTMARGIN | EC_RIGHTMARGIN, MAKELONG(0,0));
1516 SendMessageA(hwEdit, WM_SETFONT, (WPARAM)hfont, 0);
1517 margins = SendMessage(hwEdit, EM_GETMARGINS, 0, 0);
1518 ok(LOWORD(margins) == 0 || broken(LOWORD(margins) == LOWORD(font_margins)), /* win95 */
1519 "got %d\n", LOWORD(margins));
1520 ok(HIWORD(margins) == 0 || broken(HIWORD(margins) == HIWORD(font_margins)), /* win95 */
1521 "got %d\n", HIWORD(margins));
1522
1523 SendMessageA(hwEdit, EM_SETMARGINS, EC_LEFTMARGIN | EC_RIGHTMARGIN, MAKELONG(1,0));
1524 SendMessageA(hwEdit, WM_SETFONT, (WPARAM)hfont, 0);
1525 margins = SendMessage(hwEdit, EM_GETMARGINS, 0, 0);
1526 ok(LOWORD(margins) == 1 || broken(LOWORD(margins) == LOWORD(font_margins)), /* win95 */
1527 "got %d\n", LOWORD(margins));
1528 ok(HIWORD(margins) == 0 || broken(HIWORD(margins) == HIWORD(font_margins)), /* win95 */
1529 "got %d\n", HIWORD(margins));
1530
1531 SendMessageA(hwEdit, EM_SETMARGINS, EC_LEFTMARGIN | EC_RIGHTMARGIN, MAKELONG(1,1));
1532 SendMessageA(hwEdit, WM_SETFONT, (WPARAM)hfont, 0);
1533 margins = SendMessage(hwEdit, EM_GETMARGINS, 0, 0);
1534 ok(LOWORD(margins) == 1 || broken(LOWORD(margins) == LOWORD(font_margins)), /* win95 */
1535 "got %d\n", LOWORD(margins));
1536 ok(HIWORD(margins) == 1 || broken(HIWORD(margins) == HIWORD(font_margins)), /* win95 */
1537 "got %d\n", HIWORD(margins));
1538
1539 SendMessageA(hwEdit, EM_SETMARGINS, EC_LEFTMARGIN | EC_RIGHTMARGIN, MAKELONG(EC_USEFONTINFO,EC_USEFONTINFO));
1540 margins = SendMessage(hwEdit, EM_GETMARGINS, 0, 0);
1541 ok(LOWORD(margins) == 1 || broken(LOWORD(margins) == LOWORD(font_margins)), /* win95 */
1542 "got %d\n", LOWORD(margins));
1543 ok(HIWORD(margins) == 1 || broken(HIWORD(margins) == HIWORD(font_margins)), /* win95 */
1544 "got %d\n", HIWORD(margins));
1545
1546 SendMessageA(hwEdit, WM_SETFONT, (WPARAM)hfont2, 0);
1547 margins = SendMessage(hwEdit, EM_GETMARGINS, 0, 0);
1548 ok(LOWORD(margins) == 1 || broken(LOWORD(margins) != 1 && LOWORD(margins) != LOWORD(font_margins)), /* win95 */
1549 "got %d\n", LOWORD(margins));
1550 ok(HIWORD(margins) == 1 || broken(HIWORD(margins) != 1 && HIWORD(margins) != HIWORD(font_margins)), /* win95 */
1551 "got %d\n", HIWORD(margins));
1552
1553 /* Above a certain size threshold then the margin is updated */
1554 SetWindowPos(hwEdit, NULL, 10, 10, 1000, 100, SWP_NOZORDER | SWP_NOACTIVATE);
1555 SendMessageA(hwEdit, EM_SETMARGINS, EC_LEFTMARGIN | EC_RIGHTMARGIN, MAKELONG(1,0));
1556 SendMessageA(hwEdit, WM_SETFONT, (WPARAM)hfont, 0);
1557 margins = SendMessage(hwEdit, EM_GETMARGINS, 0, 0);
1558 ok(LOWORD(margins) == LOWORD(font_margins), "got %d\n", LOWORD(margins));
1559 ok(HIWORD(margins) == HIWORD(font_margins), "got %d\n", HIWORD(margins));
1560
1561 SendMessageA(hwEdit, EM_SETMARGINS, EC_LEFTMARGIN | EC_RIGHTMARGIN, MAKELONG(1,1));
1562 SendMessageA(hwEdit, WM_SETFONT, (WPARAM)hfont, 0);
1563 margins = SendMessage(hwEdit, EM_GETMARGINS, 0, 0);
1564 ok(LOWORD(margins) == LOWORD(font_margins), "got %d\n", LOWORD(margins));
1565 ok(HIWORD(margins) == HIWORD(font_margins), "got %d\n", HIWORD(margins));
1566
1567 SendMessageA(hwEdit, EM_SETMARGINS, EC_LEFTMARGIN | EC_RIGHTMARGIN, MAKELONG(EC_USEFONTINFO,EC_USEFONTINFO));
1568 SendMessageA(hwEdit, WM_SETFONT, (WPARAM)hfont, 0);
1569 margins = SendMessage(hwEdit, EM_GETMARGINS, 0, 0);
1570 ok(LOWORD(margins) == LOWORD(font_margins), "got %d\n", LOWORD(margins));
1571 ok(HIWORD(margins) == HIWORD(font_margins), "got %d\n", HIWORD(margins));
1572 SendMessageA(hwEdit, WM_SETFONT, (WPARAM)hfont2, 0);
1573 margins = SendMessage(hwEdit, EM_GETMARGINS, 0, 0);
1574 ok(LOWORD(margins) != LOWORD(font_margins) || broken(LOWORD(margins) == LOWORD(font_margins)), /* win98 */
1575 "got %d\n", LOWORD(margins));
1576 ok(HIWORD(margins) != HIWORD(font_margins), "got %d\n", HIWORD(margins));
1577
1578 SendMessageA(hwEdit, WM_SETFONT, 0, 0);
1579
1580 DeleteObject(hfont2);
1581 DeleteObject(hfont);
1582 destroy_child_editcontrol(hwEdit);
1583
1584 }
1585
1586 #define edit_pos_ok(exp, got, txt) \
1587 ok(exp == got, "wrong " #txt " expected %d got %d\n", exp, got);
1588
1589 #define check_pos(hwEdit, set_height, test_top, test_height, test_left) \
1590 do { \
1591 RECT format_rect; \
1592 int left_margin; \
1593 set_client_height(hwEdit, set_height); \
1594 SendMessage(hwEdit, EM_GETRECT, 0, (LPARAM) &format_rect); \
1595 left_margin = LOWORD(SendMessage(hwEdit, EM_GETMARGINS, 0, 0)); \
1596 edit_pos_ok(test_top, format_rect.top, vertical position); \
1597 edit_pos_ok((int)test_height, format_rect.bottom - format_rect.top, height); \
1598 edit_pos_ok(test_left, format_rect.left - left_margin, left); \
1599 } while(0)
1600
1601 static void test_text_position_style(DWORD style)
1602 {
1603 HWND hwEdit;
1604 HFONT font, oldFont;
1605 HDC dc;
1606 TEXTMETRIC metrics;
1607 INT b, bm, b2, b3;
1608 BOOL xb, single_line = !(style & ES_MULTILINE);
1609
1610 b = GetSystemMetrics(SM_CYBORDER) + 1;
1611 b2 = 2 * b;
1612 b3 = 3 * b;
1613 bm = b2 - 1;
1614
1615 /* Get a stock font for which we can determine the metrics */
1616 font = GetStockObject(SYSTEM_FONT);
1617 ok (font != NULL, "GetStockObjcet SYSTEM_FONT failed\n");
1618 dc = GetDC(NULL);
1619 ok (dc != NULL, "GetDC() failed\n");
1620 oldFont = SelectObject(dc, font);
1621 xb = GetTextMetrics(dc, &metrics);
1622 ok (xb, "GetTextMetrics failed\n");
1623 SelectObject(dc, oldFont);
1624 ReleaseDC(NULL, dc);
1625
1626 /* Windows' edit control has some bugs in multi-line mode:
1627 * - Sometimes the format rectangle doesn't get updated
1628 * (see workaround in set_client_height())
1629 * - If the height of the control is smaller than the height of a text
1630 * line, the format rectangle is still as high as a text line
1631 * (higher than the client rectangle) and the caret is not shown
1632 */
1633
1634 /* Edit controls that are in a parent window */
1635
1636 hwEdit = create_child_editcontrol(style | WS_VISIBLE, 0);
1637 SendMessage(hwEdit, WM_SETFONT, (WPARAM) font, FALSE);
1638 if (single_line)
1639 check_pos(hwEdit, metrics.tmHeight - 1, 0, metrics.tmHeight - 1, 0);
1640 check_pos(hwEdit, metrics.tmHeight , 0, metrics.tmHeight , 0);
1641 check_pos(hwEdit, metrics.tmHeight + 1, 0, metrics.tmHeight , 0);
1642 check_pos(hwEdit, metrics.tmHeight + 2, 0, metrics.tmHeight , 0);
1643 check_pos(hwEdit, metrics.tmHeight + 10, 0, metrics.tmHeight , 0);
1644 destroy_child_editcontrol(hwEdit);
1645
1646 hwEdit = create_child_editcontrol(style | WS_BORDER | WS_VISIBLE, 0);
1647 SendMessage(hwEdit, WM_SETFONT, (WPARAM) font, FALSE);
1648 if (single_line)
1649 check_pos(hwEdit, metrics.tmHeight - 1, 0, metrics.tmHeight - 1, b);
1650 check_pos(hwEdit, metrics.tmHeight , 0, metrics.tmHeight , b);
1651 check_pos(hwEdit, metrics.tmHeight + 1, 0, metrics.tmHeight , b);
1652 check_pos(hwEdit, metrics.tmHeight + bm, 0, metrics.tmHeight , b);
1653 check_pos(hwEdit, metrics.tmHeight + b2, b, metrics.tmHeight , b);
1654 check_pos(hwEdit, metrics.tmHeight + b3, b, metrics.tmHeight , b);
1655 destroy_child_editcontrol(hwEdit);
1656
1657 hwEdit = create_child_editcontrol(style | WS_VISIBLE, WS_EX_CLIENTEDGE);
1658 SendMessage(hwEdit, WM_SETFONT, (WPARAM) font, FALSE);
1659 if (single_line)
1660 check_pos(hwEdit, metrics.tmHeight - 1, 0, metrics.tmHeight - 1, 1);
1661 check_pos(hwEdit, metrics.tmHeight , 0, metrics.tmHeight , 1);
1662 check_pos(hwEdit, metrics.tmHeight + 1, 0, metrics.tmHeight , 1);
1663 check_pos(hwEdit, metrics.tmHeight + 2, 1, metrics.tmHeight , 1);
1664 check_pos(hwEdit, metrics.tmHeight + 10, 1, metrics.tmHeight , 1);
1665 destroy_child_editcontrol(hwEdit);
1666
1667 hwEdit = create_child_editcontrol(style | WS_BORDER | WS_VISIBLE, WS_EX_CLIENTEDGE);
1668 SendMessage(hwEdit, WM_SETFONT, (WPARAM) font, FALSE);
1669 if (single_line)
1670 check_pos(hwEdit, metrics.tmHeight - 1, 0, metrics.tmHeight - 1, 1);
1671 check_pos(hwEdit, metrics.tmHeight , 0, metrics.tmHeight , 1);
1672 check_pos(hwEdit, metrics.tmHeight + 1, 0, metrics.tmHeight , 1);
1673 check_pos(hwEdit, metrics.tmHeight + 2, 1, metrics.tmHeight , 1);
1674 check_pos(hwEdit, metrics.tmHeight + 10, 1, metrics.tmHeight , 1);
1675 destroy_child_editcontrol(hwEdit);
1676
1677
1678 /* Edit controls that are popup windows */
1679
1680 hwEdit = create_editcontrol(style | WS_POPUP, 0);
1681 SendMessage(hwEdit, WM_SETFONT, (WPARAM) font, FALSE);
1682 if (single_line)
1683 check_pos(hwEdit, metrics.tmHeight - 1, 0, metrics.tmHeight - 1, 0);
1684 check_pos(hwEdit, metrics.tmHeight , 0, metrics.tmHeight , 0);
1685 check_pos(hwEdit, metrics.tmHeight + 1, 0, metrics.tmHeight , 0);
1686 check_pos(hwEdit, metrics.tmHeight + 2, 0, metrics.tmHeight , 0);
1687 check_pos(hwEdit, metrics.tmHeight + 10, 0, metrics.tmHeight , 0);
1688 DestroyWindow(hwEdit);
1689
1690 hwEdit = create_editcontrol(style | WS_POPUP | WS_BORDER, 0);
1691 SendMessage(hwEdit, WM_SETFONT, (WPARAM) font, FALSE);
1692 if (single_line)
1693 check_pos(hwEdit, metrics.tmHeight - 1, 0, metrics.tmHeight - 1, b);
1694 check_pos(hwEdit, metrics.tmHeight , 0, metrics.tmHeight , b);
1695 check_pos(hwEdit, metrics.tmHeight + 1, 0, metrics.tmHeight , b);
1696 check_pos(hwEdit, metrics.tmHeight + bm, 0, metrics.tmHeight , b);
1697 check_pos(hwEdit, metrics.tmHeight + b2, b, metrics.tmHeight , b);
1698 check_pos(hwEdit, metrics.tmHeight + b3, b, metrics.tmHeight , b);
1699 DestroyWindow(hwEdit);
1700
1701 hwEdit = create_editcontrol(style | WS_POPUP, WS_EX_CLIENTEDGE);
1702 SendMessage(hwEdit, WM_SETFONT, (WPARAM) font, FALSE);
1703 if (single_line)
1704 check_pos(hwEdit, metrics.tmHeight - 1, 0, metrics.tmHeight - 1, 1);
1705 check_pos(hwEdit, metrics.tmHeight , 0, metrics.tmHeight , 1);
1706 check_pos(hwEdit, metrics.tmHeight + 1, 0, metrics.tmHeight , 1);
1707 check_pos(hwEdit, metrics.tmHeight + 2, 1, metrics.tmHeight , 1);
1708 check_pos(hwEdit, metrics.tmHeight + 10, 1, metrics.tmHeight , 1);
1709 DestroyWindow(hwEdit);
1710
1711 hwEdit = create_editcontrol(style | WS_POPUP | WS_BORDER, WS_EX_CLIENTEDGE);
1712 SendMessage(hwEdit, WM_SETFONT, (WPARAM) font, FALSE);
1713 if (single_line)
1714 check_pos(hwEdit, metrics.tmHeight - 1, 0, metrics.tmHeight - 1, 1);
1715 check_pos(hwEdit, metrics.tmHeight , 0, metrics.tmHeight , 1);
1716 check_pos(hwEdit, metrics.tmHeight + 1, 0, metrics.tmHeight , 1);
1717 check_pos(hwEdit, metrics.tmHeight + 2, 1, metrics.tmHeight , 1);
1718 check_pos(hwEdit, metrics.tmHeight + 10, 1, metrics.tmHeight , 1);
1719 DestroyWindow(hwEdit);
1720 }
1721
1722 static void test_text_position(void)
1723 {
1724 trace("EDIT: Text position (Single line)\n");
1725 test_text_position_style(ES_AUTOHSCROLL | ES_AUTOVSCROLL);
1726 trace("EDIT: Text position (Multi line)\n");
1727 test_text_position_style(ES_MULTILINE | ES_AUTOHSCROLL | ES_AUTOVSCROLL);
1728 }
1729
1730 static void test_espassword(void)
1731 {
1732 HWND hwEdit;
1733 LONG r;
1734 char buffer[1024];
1735 const char* password = "secret";
1736
1737 hwEdit = create_editcontrol(ES_PASSWORD, 0);
1738 r = get_edit_style(hwEdit);
1739 ok(r == ES_PASSWORD, "Wrong style expected ES_PASSWORD got: 0x%x\n", r);
1740 /* set text */
1741 r = SendMessage(hwEdit , WM_SETTEXT, 0, (LPARAM) password);
1742 ok(r == TRUE, "Expected: %d, got: %d\n", TRUE, r);
1743
1744 /* select all, cut (ctrl-x) */
1745 SendMessage(hwEdit, EM_SETSEL, 0, -1);
1746 r = SendMessage(hwEdit, WM_CHAR, 24, 0);
1747 ok(1 == r, "Expected: %d, got: %d\n", 1, r);
1748
1749 /* get text */
1750 r = SendMessage(hwEdit, WM_GETTEXT, 1024, (LPARAM) buffer);
1751 ok(r == strlen(password), "Expected: %s, got len %d\n", password, r);
1752 ok(strcmp(buffer, password) == 0, "expected %s, got %s\n", password, buffer);
1753
1754 r = OpenClipboard(hwEdit);
1755 ok(r == TRUE, "expected %d, got %d\n", TRUE, r);
1756 r = EmptyClipboard();
1757 ok(r == TRUE, "expected %d, got %d\n", TRUE, r);
1758 r = CloseClipboard();
1759 ok(r == TRUE, "expected %d, got %d\n", TRUE, r);
1760
1761 /* select all, copy (ctrl-c) and paste (ctrl-v) */
1762 SendMessage(hwEdit, EM_SETSEL, 0, -1);
1763 r = SendMessage(hwEdit, WM_CHAR, 3, 0);
1764 ok(1 == r, "Expected: %d, got: %d\n", 1, r);
1765 r = SendMessage(hwEdit, WM_CHAR, 22, 0);
1766 ok(1 == r, "Expected: %d, got: %d\n", 1, r);
1767
1768 /* get text */
1769 buffer[0] = 0;
1770 r = SendMessage(hwEdit, WM_GETTEXT, 1024, (LPARAM) buffer);
1771 ok(r == 0, "Expected: 0, got: %d\n", r);
1772 ok(strcmp(buffer, "") == 0, "expected empty string, got %s\n", buffer);
1773
1774 DestroyWindow (hwEdit);
1775 }
1776
1777 static void test_undo(void)
1778 {
1779 HWND hwEdit;
1780 LONG r;
1781 DWORD cpMin, cpMax;
1782 char buffer[1024];
1783 const char* text = "undo this";
1784
1785 hwEdit = create_editcontrol(0, 0);
1786 r = get_edit_style(hwEdit);
1787 ok(0 == r, "Wrong style expected 0x%x got: 0x%x\n", 0, r);
1788
1789 /* set text */
1790 r = SendMessage(hwEdit , WM_SETTEXT, 0, (LPARAM) text);
1791 ok(TRUE == r, "Expected: %d, got: %d\n", TRUE, r);
1792
1793 /* select all, */
1794 cpMin = cpMax = 0xdeadbeef;
1795 SendMessage(hwEdit, EM_SETSEL, 0, -1);
1796 r = SendMessage(hwEdit, EM_GETSEL, (WPARAM) &cpMin, (LPARAM) &cpMax);
1797 ok((strlen(text) << 16) == r, "Unexpected length %d\n", r);
1798 ok(0 == cpMin, "Expected: %d, got %d\n", 0, cpMin);
1799 ok(9 == cpMax, "Expected: %d, got %d\n", 9, cpMax);
1800
1801 /* cut (ctrl-x) */
1802 r = SendMessage(hwEdit, WM_CHAR, 24, 0);
1803 ok(1 == r, "Expected: %d, got: %d\n", 1, r);
1804
1805 /* get text */
1806 buffer[0] = 0;
1807 r = SendMessage(hwEdit, WM_GETTEXT, 1024, (LPARAM) buffer);
1808 ok(0 == r, "Expected: %d, got len %d\n", 0, r);
1809 ok(0 == strcmp(buffer, ""), "expected %s, got %s\n", "", buffer);
1810
1811 /* undo (ctrl-z) */
1812 r = SendMessage(hwEdit, WM_CHAR, 26, 0);
1813 ok(1 == r, "Expected: %d, got: %d\n", 1, r);
1814
1815 /* get text */
1816 buffer[0] = 0;
1817 r = SendMessage(hwEdit, WM_GETTEXT, 1024, (LPARAM) buffer);
1818 ok(strlen(text) == r, "Unexpected length %d\n", r);
1819 ok(0 == strcmp(buffer, text), "expected %s, got %s\n", text, buffer);
1820
1821 /* undo again (ctrl-z) */
1822 r = SendMessage(hwEdit, WM_CHAR, 26, 0);
1823 ok(1 == r, "Expected: %d, got: %d\n", 1, r);
1824
1825 /* get text */
1826 buffer[0] = 0;
1827 r = SendMessage(hwEdit, WM_GETTEXT, 1024, (LPARAM) buffer);
1828 ok(r == 0, "Expected: %d, got len %d\n", 0, r);
1829 ok(0 == strcmp(buffer, ""), "expected %s, got %s\n", "", buffer);
1830
1831 DestroyWindow (hwEdit);
1832 }
1833
1834 static void test_enter(void)
1835 {
1836 HWND hwEdit;
1837 LONG r;
1838 char buffer[16];
1839
1840 /* multiline */
1841 hwEdit = create_editcontrol(ES_MULTILINE, 0);
1842 r = get_edit_style(hwEdit);
1843 ok(ES_MULTILINE == r, "Wrong style expected ES_MULTILINE got: 0x%x\n", r);
1844
1845 /* set text */
1846 r = SendMessage(hwEdit , WM_SETTEXT, 0, (LPARAM) "");
1847 ok(TRUE == r, "Expected: %d, got: %d\n", TRUE, r);
1848
1849 r = SendMessage(hwEdit, WM_CHAR, VK_RETURN, 0);
1850 ok(1 == r, "Expected: %d, got: %d\n", 1, r);
1851
1852 /* get text */
1853 buffer[0] = 0;
1854 r = SendMessage(hwEdit, WM_GETTEXT, 16, (LPARAM) buffer);
1855 ok(2 == r, "Expected: %d, got len %d\n", 2, r);
1856 ok(0 == strcmp(buffer, "\r\n"), "expected \"\\r\\n\", got \"%s\"\n", buffer);
1857
1858 DestroyWindow (hwEdit);
1859
1860 /* single line */
1861 hwEdit = create_editcontrol(0, 0);
1862 r = get_edit_style(hwEdit);
1863 ok(0 == r, "Wrong style expected 0x%x got: 0x%x\n", 0, r);
1864
1865 /* set text */
1866 r = SendMessage(hwEdit , WM_SETTEXT, 0, (LPARAM) "");
1867 ok(TRUE == r, "Expected: %d, got: %d\n", TRUE, r);
1868
1869 r = SendMessage(hwEdit, WM_CHAR, VK_RETURN, 0);
1870 ok(1 == r, "Expected: %d, got: %d\n", 1, r);
1871
1872 /* get text */
1873 buffer[0] = 0;
1874 r = SendMessage(hwEdit, WM_GETTEXT, 16, (LPARAM) buffer);
1875 ok(0 == r, "Expected: %d, got len %d\n", 0, r);
1876 ok(0 == strcmp(buffer, ""), "expected \"\", got \"%s\"\n", buffer);
1877
1878 DestroyWindow (hwEdit);
1879
1880 /* single line with ES_WANTRETURN */
1881 hwEdit = create_editcontrol(ES_WANTRETURN, 0);
1882 r = get_edit_style(hwEdit);
1883 ok(ES_WANTRETURN == r, "Wrong style expected ES_WANTRETURN got: 0x%x\n", r);
1884
1885 /* set text */
1886 r = SendMessage(hwEdit , WM_SETTEXT, 0, (LPARAM) "");
1887 ok(TRUE == r, "Expected: %d, got: %d\n", TRUE, r);
1888
1889 r = SendMessage(hwEdit, WM_CHAR, VK_RETURN, 0);
1890 ok(1 == r, "Expected: %d, got: %d\n", 1, r);
1891
1892 /* get text */
1893 buffer[0] = 0;
1894 r = SendMessage(hwEdit, WM_GETTEXT, 16, (LPARAM) buffer);
1895 ok(0 == r, "Expected: %d, got len %d\n", 0, r);
1896 ok(0 == strcmp(buffer, ""), "expected \"\", got \"%s\"\n", buffer);
1897
1898 DestroyWindow (hwEdit);
1899 }
1900
1901 static void test_tab(void)
1902 {
1903 HWND hwEdit;
1904 LONG r;
1905 char buffer[16];
1906
1907 /* multiline */
1908 hwEdit = create_editcontrol(ES_MULTILINE, 0);
1909 r = get_edit_style(hwEdit);
1910 ok(ES_MULTILINE == r, "Wrong style expected ES_MULTILINE got: 0x%x\n", r);
1911
1912 /* set text */
1913 r = SendMessage(hwEdit , WM_SETTEXT, 0, (LPARAM) "");
1914 ok(TRUE == r, "Expected: %d, got: %d\n", TRUE, r);
1915
1916 r = SendMessage(hwEdit, WM_CHAR, VK_TAB, 0);
1917 ok(1 == r, "Expected: %d, got: %d\n", 1, r);
1918
1919 /* get text */
1920 buffer[0] = 0;
1921 r = SendMessage(hwEdit, WM_GETTEXT, 16, (LPARAM) buffer);
1922 ok(1 == r, "Expected: %d, got len %d\n", 1, r);
1923 ok(0 == strcmp(buffer, "\t"), "expected \"\\t\", got \"%s\"\n", buffer);
1924
1925 DestroyWindow (hwEdit);
1926
1927 /* single line */
1928 hwEdit = create_editcontrol(0, 0);
1929 r = get_edit_style(hwEdit);
1930 ok(0 == r, "Wrong style expected 0x%x got: 0x%x\n", 0, r);
1931
1932 /* set text */
1933 r = SendMessage(hwEdit , WM_SETTEXT, 0, (LPARAM) "");
1934 ok(TRUE == r, "Expected: %d, got: %d\n", TRUE, r);
1935
1936 r = SendMessage(hwEdit, WM_CHAR, VK_TAB, 0);
1937 ok(1 == r, "Expected: %d, got: %d\n", 1, r);
1938
1939 /* get text */
1940 buffer[0] = 0;
1941 r = SendMessage(hwEdit, WM_GETTEXT, 16, (LPARAM) buffer);
1942 ok(0 == r, "Expected: %d, got len %d\n", 0, r);
1943 ok(0 == strcmp(buffer, ""), "expected \"\", got \"%s\"\n", buffer);
1944
1945 DestroyWindow (hwEdit);
1946 }
1947
1948 static void test_edit_dialog(void)
1949 {
1950 int r;
1951
1952 /* from bug 11841 */
1953 r = DialogBoxParam(hinst, "EDIT_READONLY_DIALOG", NULL, edit_dialog_proc, 0);
1954 ok(333 == r, "Expected %d, got %d\n", 333, r);
1955 r = DialogBoxParam(hinst, "EDIT_READONLY_DIALOG", NULL, edit_dialog_proc, 1);
1956 ok(111 == r, "Expected %d, got %d\n", 111, r);
1957 r = DialogBoxParam(hinst, "EDIT_READONLY_DIALOG", NULL, edit_dialog_proc, 2);
1958 ok(444 == r, "Expected %d, got %d\n", 444, r);
1959
1960 /* more tests for WM_CHAR */
1961 r = DialogBoxParam(hinst, "EDIT_READONLY_DIALOG", NULL, edit_dialog_proc, 3);
1962 ok(444 == r, "Expected %d, got %d\n", 444, r);
1963 r = DialogBoxParam(hinst, "EDIT_READONLY_DIALOG", NULL, edit_dialog_proc, 4);
1964 ok(444 == r, "Expected %d, got %d\n", 444, r);
1965 r = DialogBoxParam(hinst, "EDIT_READONLY_DIALOG", NULL, edit_dialog_proc, 5);
1966 ok(444 == r, "Expected %d, got %d\n", 444, r);
1967
1968 /* more tests for WM_KEYDOWN + WM_CHAR */
1969 r = DialogBoxParam(hinst, "EDIT_READONLY_DIALOG", NULL, edit_dialog_proc, 6);
1970 ok(444 == r, "Expected %d, got %d\n", 444, r);
1971 r = DialogBoxParam(hinst, "EDIT_READONLY_DIALOG", NULL, edit_dialog_proc, 7);
1972 ok(444 == r, "Expected %d, got %d\n", 444, r);
1973 r = DialogBoxParam(hinst, "EDIT_READONLY_DIALOG", NULL, edit_dialog_proc, 8);
1974 ok(444 == r, "Expected %d, got %d\n", 444, r);
1975
1976 /* tests with an editable edit control */
1977 r = DialogBoxParam(hinst, "EDIT_DIALOG", NULL, edit_dialog_proc, 0);
1978 ok(333 == r, "Expected %d, got %d\n", 333, r);
1979 r = DialogBoxParam(hinst, "EDIT_DIALOG", NULL, edit_dialog_proc, 1);
1980 ok(111 == r, "Expected %d, got %d\n", 111, r);
1981 r = DialogBoxParam(hinst, "EDIT_DIALOG", NULL, edit_dialog_proc, 2);
1982 ok(444 == r, "Expected %d, got %d\n", 444, r);
1983
1984 /* tests for WM_CHAR */
1985 r = DialogBoxParam(hinst, "EDIT_DIALOG", NULL, edit_dialog_proc, 3);
1986 ok(444 == r, "Expected %d, got %d\n", 444, r);
1987 r = DialogBoxParam(hinst, "EDIT_DIALOG", NULL, edit_dialog_proc, 4);
1988 ok(444 == r, "Expected %d, got %d\n", 444, r);
1989 r = DialogBoxParam(hinst, "EDIT_DIALOG", NULL, edit_dialog_proc, 5);
1990 ok(444 == r, "Expected %d, got %d\n", 444, r);
1991
1992 /* tests for WM_KEYDOWN + WM_CHAR */
1993 r = DialogBoxParam(hinst, "EDIT_DIALOG", NULL, edit_dialog_proc, 6);
1994 ok(444 == r, "Expected %d, got %d\n", 444, r);
1995 r = DialogBoxParam(hinst, "EDIT_DIALOG", NULL, edit_dialog_proc, 7);
1996 ok(444 == r, "Expected %d, got %d\n", 444, r);
1997 r = DialogBoxParam(hinst, "EDIT_DIALOG", NULL, edit_dialog_proc, 8);
1998 ok(444 == r, "Expected %d, got %d\n", 444, r);
1999
2000 /* multiple tab tests */
2001 r = DialogBoxParam(hinst, "EDIT_DIALOG", NULL, edit_dialog_proc, 9);
2002 ok(22 == r, "Expected %d, got %d\n", 22, r);
2003 r = DialogBoxParam(hinst, "EDIT_DIALOG", NULL, edit_dialog_proc, 10);
2004 ok(33 == r, "Expected %d, got %d\n", 33, r);
2005 }
2006
2007 static void test_multi_edit_dialog(void)
2008 {
2009 int r;
2010
2011 /* test for multiple edit dialogs (bug 12319) */
2012 r = DialogBoxParam(hinst, "MULTI_EDIT_DIALOG", NULL, multi_edit_dialog_proc, 0);
2013 ok(2222 == r, "Expected %d, got %d\n", 2222, r);
2014 r = DialogBoxParam(hinst, "MULTI_EDIT_DIALOG", NULL, multi_edit_dialog_proc, 1);
2015 ok(1111 == r, "Expected %d, got %d\n", 1111, r);
2016 r = DialogBoxParam(hinst, "MULTI_EDIT_DIALOG", NULL, multi_edit_dialog_proc, 2);
2017 ok(2222 == r, "Expected %d, got %d\n", 2222, r);
2018 r = DialogBoxParam(hinst, "MULTI_EDIT_DIALOG", NULL, multi_edit_dialog_proc, 3);
2019 ok(11 == r, "Expected %d, got %d\n", 11, r);
2020 }
2021
2022 static void test_wantreturn_edit_dialog(void)
2023 {
2024 int r;
2025
2026 /* tests for WM_KEYDOWN */
2027 r = DialogBoxParam(hinst, "EDIT_WANTRETURN_DIALOG", NULL, edit_wantreturn_dialog_proc, 0);
2028 ok(333 == r, "Expected %d, got %d\n", 333, r);
2029 r = DialogBoxParam(hinst, "EDIT_WANTRETURN_DIALOG", NULL, edit_wantreturn_dialog_proc, 1);
2030 ok(444 == r, "Expected %d, got %d\n", 444, r);
2031 r = DialogBoxParam(hinst, "EDIT_WANTRETURN_DIALOG", NULL, edit_wantreturn_dialog_proc, 2);
2032 ok(444 == r, "Expected %d, got %d\n", 444, r);
2033
2034 /* tests for WM_CHAR */
2035 r = DialogBoxParam(hinst, "EDIT_WANTRETURN_DIALOG", NULL, edit_wantreturn_dialog_proc, 3);
2036 ok(444 == r, "Expected %d, got %d\n", 444, r);
2037 r = DialogBoxParam(hinst, "EDIT_WANTRETURN_DIALOG", NULL, edit_wantreturn_dialog_proc, 4);
2038 ok(444 == r, "Expected %d, got %d\n", 444, r);
2039 r = DialogBoxParam(hinst, "EDIT_WANTRETURN_DIALOG", NULL, edit_wantreturn_dialog_proc, 5);
2040 ok(444 == r, "Expected %d, got %d\n", 444, r);
2041
2042 /* tests for WM_KEYDOWN + WM_CHAR */
2043 r = DialogBoxParam(hinst, "EDIT_WANTRETURN_DIALOG", NULL, edit_wantreturn_dialog_proc, 6);
2044 ok(444 == r, "Expected %d, got %d\n", 444, r);
2045 r = DialogBoxParam(hinst, "EDIT_WANTRETURN_DIALOG", NULL, edit_wantreturn_dialog_proc, 7);
2046 ok(444 == r, "Expected %d, got %d\n", 444, r);
2047 r = DialogBoxParam(hinst, "EDIT_WANTRETURN_DIALOG", NULL, edit_wantreturn_dialog_proc, 8);
2048 ok(444 == r, "Expected %d, got %d\n", 444, r);
2049 }
2050
2051 static void test_singleline_wantreturn_edit_dialog(void)
2052 {
2053 int r;
2054
2055 /* tests for WM_KEYDOWN */
2056 r = DialogBoxParam(hinst, "EDIT_SINGLELINE_DIALOG", NULL, edit_singleline_dialog_proc, 0);
2057 ok(222 == r, "Expected %d, got %d\n", 222, r);
2058 r = DialogBoxParam(hinst, "EDIT_SINGLELINE_DIALOG", NULL, edit_singleline_dialog_proc, 1);
2059 ok(111 == r, "Expected %d, got %d\n", 111, r);
2060 r = DialogBoxParam(hinst, "EDIT_SINGLELINE_DIALOG", NULL, edit_singleline_dialog_proc, 2);
2061 ok(444 == r, "Expected %d, got %d\n", 444, r);
2062
2063 /* tests for WM_CHAR */
2064 r = DialogBoxParam(hinst, "EDIT_SINGLELINE_DIALOG", NULL, edit_singleline_dialog_proc, 3);
2065 ok(444 == r, "Expected %d, got %d\n", 444, r);
2066 r = DialogBoxParam(hinst, "EDIT_SINGLELINE_DIALOG", NULL, edit_singleline_dialog_proc, 4);
2067 ok(444 == r, "Expected %d, got %d\n", 444, r);
2068 r = DialogBoxParam(hinst, "EDIT_SINGLELINE_DIALOG", NULL, edit_singleline_dialog_proc, 5);
2069 ok(444 == r, "Expected %d, got %d\n", 444, r);
2070
2071 /* tests for WM_KEYDOWN + WM_CHAR */
2072 r = DialogBoxParam(hinst, "EDIT_SINGLELINE_DIALOG", NULL, edit_singleline_dialog_proc, 6);
2073 ok(222 == r, "Expected %d, got %d\n", 222, r);
2074 r = DialogBoxParam(hinst, "EDIT_SINGLELINE_DIALOG", NULL, edit_singleline_dialog_proc, 7);
2075 ok(111 == r, "Expected %d, got %d\n", 111, r);
2076 r = DialogBoxParam(hinst, "EDIT_SINGLELINE_DIALOG", NULL, edit_singleline_dialog_proc, 8);
2077 ok(444 == r, "Expected %d, got %d\n", 444, r);
2078
2079 /* tests for WM_KEYDOWN */
2080 r = DialogBoxParam(hinst, "EDIT_SINGLELINE_WANTRETURN_DIALOG", NULL, edit_singleline_dialog_proc, 0);
2081 ok(222 == r, "Expected %d, got %d\n", 222, r);
2082 r = DialogBoxParam(hinst, "EDIT_SINGLELINE_WANTRETURN_DIALOG", NULL, edit_singleline_dialog_proc, 1);
2083 ok(111 == r, "Expected %d, got %d\n", 111, r);
2084 r = DialogBoxParam(hinst, "EDIT_SINGLELINE_WANTRETURN_DIALOG", NULL, edit_singleline_dialog_proc, 2);
2085 ok(444 == r, "Expected %d, got %d\n", 444, r);
2086
2087 /* tests for WM_CHAR */
2088 r = DialogBoxParam(hinst, "EDIT_SINGLELINE_WANTRETURN_DIALOG", NULL, edit_singleline_dialog_proc, 3);
2089 ok(444 == r, "Expected %d, got %d\n", 444, r);
2090 r = DialogBoxParam(hinst, "EDIT_SINGLELINE_WANTRETURN_DIALOG", NULL, edit_singleline_dialog_proc, 4);
2091 ok(444 == r, "Expected %d, got %d\n", 444, r);
2092 r = DialogBoxParam(hinst, "EDIT_SINGLELINE_WANTRETURN_DIALOG", NULL, edit_singleline_dialog_proc, 5);
2093 ok(444 == r, "Expected %d, got %d\n", 444, r);
2094
2095 /* tests for WM_KEYDOWN + WM_CHAR */
2096 r = DialogBoxParam(hinst, "EDIT_SINGLELINE_WANTRETURN_DIALOG", NULL, edit_singleline_dialog_proc, 6);
2097 ok(222 == r, "Expected %d, got %d\n", 222, r);
2098 r = DialogBoxParam(hinst, "EDIT_SINGLELINE_WANTRETURN_DIALOG", NULL, edit_singleline_dialog_proc, 7);
2099 ok(111 == r, "Expected %d, got %d\n", 111, r);
2100 r = DialogBoxParam(hinst, "EDIT_SINGLELINE_WANTRETURN_DIALOG", NULL, edit_singleline_dialog_proc, 8);
2101 ok(444 == r, "Expected %d, got %d\n", 444, r);
2102 }
2103
2104 static int child_edit_wmkeydown_num_messages = 0;
2105 static INT_PTR CALLBACK child_edit_wmkeydown_proc(HWND hdlg, UINT msg, WPARAM wparam, LPARAM lparam)
2106 {
2107 switch (msg)
2108 {
2109 case WM_DESTROY:
2110 case WM_NCDESTROY:
2111 break;
2112
2113 default:
2114 child_edit_wmkeydown_num_messages++;
2115 break;
2116 }
2117
2118 return FALSE;
2119 }
2120
2121 static void test_child_edit_wmkeydown(void)
2122 {
2123 HWND hwEdit, hwParent;
2124 int r;
2125
2126 hwEdit = create_child_editcontrol(0, 0);
2127 hwParent = GetParent(hwEdit);
2128 SetWindowLongPtr(hwParent, GWLP_WNDPROC, (LONG_PTR)child_edit_wmkeydown_proc);
2129 r = SendMessage(hwEdit, WM_KEYDOWN, VK_RETURN, 0x1c0001);
2130 ok(1 == r, "expected 1, got %d\n", r);
2131 ok(0 == child_edit_wmkeydown_num_messages, "expected 0, got %d\n", child_edit_wmkeydown_num_messages);
2132 destroy_child_editcontrol(hwEdit);
2133 }
2134
2135 static int got_en_setfocus = 0;
2136 static int got_wm_capturechanged = 0;
2137
2138 static LRESULT CALLBACK edit4_wnd_procA(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
2139 {
2140 switch (msg) {
2141 case WM_COMMAND:
2142 switch (HIWORD(wParam)) {
2143 case EN_SETFOCUS:
2144 got_en_setfocus = 1;
2145 break;
2146 }
2147 break;
2148 case WM_CAPTURECHANGED:
2149 if (hWnd != (HWND)lParam)
2150 {
2151 got_wm_capturechanged = 1;
2152 pEndMenu();
2153 }
2154 break;
2155 }
2156 return DefWindowProcA(hWnd, msg, wParam, lParam);
2157 }
2158
2159 static void test_contextmenu_focus(void)
2160 {
2161 HWND hwndMain, hwndEdit;
2162
2163 hwndMain = CreateWindow(szEditTest4Class, "ET4", WS_OVERLAPPEDWINDOW|WS_VISIBLE,
2164 0, 0, 200, 200, NULL, NULL, hinst, NULL);
2165 assert(hwndMain);
2166
2167 hwndEdit = CreateWindow("EDIT", NULL,
2168 WS_CHILD|WS_BORDER|WS_VISIBLE|ES_LEFT|ES_AUTOHSCROLL,
2169 0, 0, 150, 50, /* important this not be 0 size. */
2170 hwndMain, (HMENU) ID_EDITTEST2, hinst, NULL);
2171 assert(hwndEdit);
2172
2173 SetFocus(NULL);
2174
2175 SetCapture(hwndMain);
2176
2177 SendMessage(hwndEdit, WM_CONTEXTMENU, (WPARAM)hwndEdit, MAKEWORD(10, 10));
2178
2179 ok(got_en_setfocus, "edit box didn't get focused\n");
2180
2181 ok(got_wm_capturechanged, "main window capture did not change\n");
2182
2183 DestroyWindow (hwndEdit);
2184 DestroyWindow (hwndMain);
2185 }
2186
2187 static BOOL RegisterWindowClasses (void)
2188 {
2189 WNDCLASSA test2;
2190 WNDCLASSA test3;
2191 WNDCLASSA test4;
2192 WNDCLASSA text_position;
2193
2194 test2.style = 0;
2195 test2.lpfnWndProc = ET2_WndProc;
2196 test2.cbClsExtra = 0;
2197 test2.cbWndExtra = 0;
2198 test2.hInstance = hinst;
2199 test2.hIcon = NULL;
2200 test2.hCursor = LoadCursorA (NULL, IDC_ARROW);
2201 test2.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
2202 test2.lpszMenuName = NULL;
2203 test2.lpszClassName = szEditTest2Class;
2204 if (!RegisterClassA(&test2)) return FALSE;
2205
2206 test3.style = 0;
2207 test3.lpfnWndProc = edit3_wnd_procA;
2208 test3.cbClsExtra = 0;
2209 test3.cbWndExtra = 0;
2210 test3.hInstance = hinst;
2211 test3.hIcon = 0;
2212 test3.hCursor = LoadCursorA(0, IDC_ARROW);
2213 test3.hbrBackground = GetStockObject(WHITE_BRUSH);
2214 test3.lpszMenuName = NULL;
2215 test3.lpszClassName = szEditTest3Class;
2216 if (!RegisterClassA(&test3)) return FALSE;
2217
2218 test4.style = 0;
2219 test4.lpfnWndProc = edit4_wnd_procA;
2220 test4.cbClsExtra = 0;
2221 test4.cbWndExtra = 0;
2222 test4.hInstance = hinst;
2223 test4.hIcon = NULL;
2224 test4.hCursor = LoadCursorA (NULL, IDC_ARROW);
2225 test4.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
2226 test4.lpszMenuName = NULL;
2227 test4.lpszClassName = szEditTest4Class;
2228 if (!RegisterClassA(&test4)) return FALSE;
2229
2230 text_position.style = CS_HREDRAW | CS_VREDRAW;
2231 text_position.cbClsExtra = 0;
2232 text_position.cbWndExtra = 0;
2233 text_position.hInstance = hinst;
2234 text_position.hIcon = NULL;
2235 text_position.hCursor = LoadCursorA(NULL, IDC_ARROW);
2236 text_position.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
2237 text_position.lpszMenuName = NULL;
2238 text_position.lpszClassName = szEditTextPositionClass;
2239 text_position.lpfnWndProc = DefWindowProc;
2240 if (!RegisterClassA(&text_position)) return FALSE;
2241
2242 return TRUE;
2243 }
2244
2245 static void UnregisterWindowClasses (void)
2246 {
2247 UnregisterClassA(szEditTest2Class, hinst);
2248 UnregisterClassA(szEditTest3Class, hinst);
2249 UnregisterClassA(szEditTest4Class, hinst);
2250 UnregisterClassA(szEditTextPositionClass, hinst);
2251 }
2252
2253 static void test_fontsize(void)
2254 {
2255 HWND hwEdit;
2256 HFONT hfont;
2257 HDC hDC;
2258 LOGFONT lf;
2259 LONG r;
2260 char szLocalString[MAXLEN];
2261 int dpi;
2262
2263 hDC = GetDC(NULL);
2264 dpi = GetDeviceCaps(hDC, LOGPIXELSY);
2265 ReleaseDC(NULL, hDC);
2266
2267 memset(&lf,0,sizeof(LOGFONTA));
2268 strcpy(lf.lfFaceName,"Arial");
2269 lf.lfHeight = -300; /* taller than the edit box */
2270 lf.lfWeight = 500;
2271 hfont = CreateFontIndirect(&lf);
2272
2273 trace("EDIT: Oversized font (Multi line)\n");
2274 hwEdit= CreateWindow("EDIT", NULL, ES_MULTILINE|ES_AUTOHSCROLL,
2275 0, 0, (150 * dpi) / 96, (50 * dpi) / 96, NULL, NULL,
2276 hinst, NULL);
2277
2278 SendMessage(hwEdit,WM_SETFONT,(WPARAM)hfont,0);
2279
2280 if (winetest_interactive)
2281 ShowWindow (hwEdit, SW_SHOW);
2282
2283 r = SendMessage(hwEdit, WM_CHAR, 'A', 1);
2284 ok(1 == r, "Expected: %d, got: %d\n", 1, r);
2285 r = SendMessage(hwEdit, WM_CHAR, 'B', 1);
2286 ok(1 == r, "Expected: %d, got: %d\n", 1, r);
2287 r = SendMessage(hwEdit, WM_CHAR, 'C', 1);
2288 ok(1 == r, "Expected: %d, got: %d\n", 1, r);
2289
2290 GetWindowText(hwEdit, szLocalString, MAXLEN);
2291 ok(lstrcmp(szLocalString, "ABC")==0,
2292 "Wrong contents of edit: %s\n", szLocalString);
2293
2294 r = SendMessage(hwEdit, EM_POSFROMCHAR,0,0);
2295 ok(r != -1,"EM_POSFROMCHAR failed index 0\n");
2296 r = SendMessage(hwEdit, EM_POSFROMCHAR,1,0);
2297 ok(r != -1,"EM_POSFROMCHAR failed index 1\n");
2298 r = SendMessage(hwEdit, EM_POSFROMCHAR,2,0);
2299 ok(r != -1,"EM_POSFROMCHAR failed index 2\n");
2300 r = SendMessage(hwEdit, EM_POSFROMCHAR,3,0);
2301 ok(r == -1,"EM_POSFROMCHAR succeeded index 3\n");
2302
2303 DestroyWindow (hwEdit);
2304 DeleteObject(hfont);
2305 }
2306
2307 struct dialog_mode_messages
2308 {
2309 int wm_getdefid, wm_close, wm_command, wm_nextdlgctl;
2310 };
2311
2312 static struct dialog_mode_messages dm_messages;
2313
2314 static void zero_dm_messages(void)
2315 {
2316 dm_messages.wm_command = 0;
2317 dm_messages.wm_close = 0;
2318 dm_messages.wm_getdefid = 0;
2319 dm_messages.wm_nextdlgctl = 0;
2320 }
2321
2322 #define test_dm_messages(wmcommand, wmclose, wmgetdefid, wmnextdlgctl) \
2323 ok(dm_messages.wm_command == wmcommand, "expected %d WM_COMMAND messages, " \
2324 "got %d\n", wmcommand, dm_messages.wm_command); \
2325 ok(dm_messages.wm_close == wmclose, "expected %d WM_CLOSE messages, " \
2326 "got %d\n", wmclose, dm_messages.wm_close); \
2327 ok(dm_messages.wm_getdefid == wmgetdefid, "expected %d WM_GETDIFID messages, " \
2328 "got %d\n", wmgetdefid, dm_messages.wm_getdefid);\
2329 ok(dm_messages.wm_nextdlgctl == wmnextdlgctl, "expected %d WM_NEXTDLGCTL messages, " \
2330 "got %d\n", wmnextdlgctl, dm_messages.wm_nextdlgctl)
2331
2332 static LRESULT CALLBACK dialog_mode_wnd_proc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
2333 {
2334 switch (iMsg)
2335 {
2336 case WM_COMMAND:
2337 dm_messages.wm_command++;
2338 break;
2339 case DM_GETDEFID:
2340 dm_messages.wm_getdefid++;
2341 return MAKELONG(ID_EDITTESTDBUTTON, DC_HASDEFID);
2342 case WM_NEXTDLGCTL:
2343 dm_messages.wm_nextdlgctl++;
2344 break;
2345 case WM_CLOSE:
2346 dm_messages.wm_close++;
2347 break;
2348 }
2349
2350 return DefWindowProc(hwnd, iMsg, wParam, lParam);
2351 }
2352
2353 static void test_dialogmode(void)
2354 {
2355 HWND hwEdit, hwParent, hwButton;
2356 MSG msg= {0};
2357 int len, r;
2358 hwEdit = create_child_editcontrol(ES_MULTILINE, 0);
2359
2360 r = SendMessage(hwEdit, WM_CHAR, VK_RETURN, 0x1c0001);
2361 ok(1 == r, "expected 1, got %d\n", r);
2362 len = SendMessage(hwEdit, WM_GETTEXTLENGTH, 0, 0);
2363 ok(11 == len, "expected 11, got %d\n", len);
2364
2365 r = SendMessage(hwEdit, WM_GETDLGCODE, 0, 0);
2366 ok(0x8d == r, "expected 0x8d, got 0x%x\n", r);
2367
2368 r = SendMessage(hwEdit, WM_CHAR, VK_RETURN, 0x1c0001);
2369 ok(1 == r, "expected 1, got %d\n", r);
2370 len = SendMessage(hwEdit, WM_GETTEXTLENGTH, 0, 0);
2371 ok(13 == len, "expected 13, got %d\n", len);
2372
2373 r = SendMessage(hwEdit, WM_GETDLGCODE, 0, (LPARAM)&msg);
2374 ok(0x8d == r, "expected 0x8d, got 0x%x\n", r);
2375 r = SendMessage(hwEdit, WM_CHAR, VK_RETURN, 0x1c0001);
2376 ok(1 == r, "expected 1, got %d\n", r);
2377 len = SendMessage(hwEdit, WM_GETTEXTLENGTH, 0, 0);
2378 ok(13 == len, "expected 13, got %d\n", len);
2379
2380 r = SendMessage(hwEdit, WM_CHAR, VK_RETURN, 0x1c0001);
2381 ok(1 == r, "expected 1, got %d\n", r);
2382 len = SendMessage(hwEdit, WM_GETTEXTLENGTH, 0, 0);
2383 ok(13 == len, "expected 13, got %d\n", len);
2384
2385 destroy_child_editcontrol(hwEdit);
2386
2387 hwEdit = create_editcontrol(ES_MULTILINE, 0);
2388
2389 r = SendMessage(hwEdit, WM_CHAR, VK_RETURN, 0x1c0001);
2390 ok(1 == r, "expected 1, got %d\n", r);
2391 len = SendMessage(hwEdit, WM_GETTEXTLENGTH, 0, 0);
2392 ok(11 == len, "expected 11, got %d\n", len);
2393
2394 msg.hwnd = hwEdit;
2395 msg.message = WM_KEYDOWN;
2396 msg.wParam = VK_BACK;
2397 msg.lParam = 0xe0001;
2398 r = SendMessage(hwEdit, WM_GETDLGCODE, VK_BACK, (LPARAM)&msg);
2399 ok(0x8d == r, "expected 0x8d, got 0x%x\n", r);
2400
2401 r = SendMessage(hwEdit, WM_CHAR, VK_RETURN, 0x1c0001);
2402 ok(1 == r, "expected 1, got %d\n", r);
2403 len = SendMessage(hwEdit, WM_GETTEXTLENGTH, 0, 0);
2404 ok(11 == len, "expected 11, got %d\n", len);
2405
2406 DestroyWindow(hwEdit);
2407
2408 hwEdit = create_child_editcontrol(0, 0);
2409 hwParent = GetParent(hwEdit);
2410 SetWindowLongPtr(hwParent, GWLP_WNDPROC, (LONG_PTR)dialog_mode_wnd_proc);
2411
2412 zero_dm_messages();
2413 r = SendMessage(hwEdit, WM_KEYDOWN, VK_ESCAPE, 0x10001);
2414 ok(1 == r, "expected 1, got %d\n", r);
2415 test_dm_messages(0, 0, 0, 0);
2416 zero_dm_messages();
2417
2418 r = SendMessage(hwEdit, WM_KEYDOWN, VK_TAB, 0xf0001);
2419 ok(1 == r, "expected 1, got %d\n", r);
2420 test_dm_messages(0, 0, 0, 0);
2421 zero_dm_messages();
2422
2423 msg.hwnd = hwEdit;
2424 msg.message = WM_KEYDOWN;
2425 msg.wParam = VK_TAB;
2426 msg.lParam = 0xf0001;
2427 r = SendMessage(hwEdit, WM_GETDLGCODE, VK_TAB, (LPARAM)&msg);
2428 ok(0x89 == r, "expected 0x89, got 0x%x\n", r);
2429 test_dm_messages(0, 0, 0, 0);
2430 zero_dm_messages();
2431
2432 r = SendMessage(hwEdit, WM_KEYDOWN, VK_TAB, 0xf0001);
2433 ok(1 == r, "expected 1, got %d\n", r);
2434 test_dm_messages(0, 0, 0, 0);
2435 zero_dm_messages();
2436
2437 destroy_child_editcontrol(hwEdit);
2438
2439 hwEdit = create_child_editcontrol(ES_MULTILINE, 0);
2440 hwParent = GetParent(hwEdit);
2441 SetWindowLongPtr(hwParent, GWLP_WNDPROC, (LONG_PTR)dialog_mode_wnd_proc);
2442
2443 r = SendMessage(hwEdit, WM_KEYDOWN, VK_TAB, 0xf0001);
2444 ok(1 == r, "expected 1, got %d\n", r);
2445 test_dm_messages(0, 0, 0, 0);
2446 zero_dm_messages();
2447
2448 msg.hwnd = hwEdit;
2449 msg.message = WM_KEYDOWN;
2450 msg.wParam = VK_ESCAPE;
2451 msg.lParam = 0x10001;
2452 r = SendMessage(hwEdit, WM_GETDLGCODE, VK_ESCAPE, (LPARAM)&msg);
2453 ok(0x8d == r, "expected 0x8d, got 0x%x\n", r);
2454 test_dm_messages(0, 0, 0, 0);
2455 zero_dm_messages();
2456
2457 r = SendMessage(hwEdit, WM_KEYDOWN, VK_ESCAPE, 0x10001);
2458 ok(1 == r, "expected 1, got %d\n", r);
2459 test_dm_messages(0, 0, 0, 0);
2460 zero_dm_messages();
2461
2462 r = SendMessage(hwEdit, WM_KEYDOWN, VK_TAB, 0xf0001);
2463 ok(1 == r, "expected 1, got %d\n", r);
2464 test_dm_messages(0, 0, 0, 1);
2465 zero_dm_messages();
2466
2467 r = SendMessage(hwEdit, WM_KEYDOWN, VK_RETURN, 0x1c0001);
2468 ok(1 == r, "expected 1, got %d\n", r);
2469 test_dm_messages(0, 0, 1, 0);
2470 zero_dm_messages();
2471
2472 hwButton = CreateWindow("BUTTON", "OK", WS_VISIBLE|WS_CHILD|BS_PUSHBUTTON,
2473 100, 100, 50, 20, hwParent, (HMENU)ID_EDITTESTDBUTTON, hinst, NULL);
2474 ok(hwButton!=NULL, "CreateWindow failed with error code %d\n", GetLastError());
2475
2476 r = SendMessage(hwEdit, WM_KEYDOWN, VK_RETURN, 0x1c0001);
2477 ok(1 == r, "expected 1, got %d\n", r);
2478 test_dm_messages(0, 0, 1, 1);
2479 zero_dm_messages();
2480
2481 DestroyWindow(hwButton);
2482 destroy_child_editcontrol(hwEdit);
2483 }
2484
2485 START_TEST(edit)
2486 {
2487 BOOL b;
2488
2489 init_function_pointers();
2490
2491 hinst = GetModuleHandleA(NULL);
2492 b = RegisterWindowClasses();
2493 ok (b, "RegisterWindowClasses failed\n");
2494 if (!b) return;
2495
2496 test_edit_control_1();
2497 test_edit_control_2();
2498 test_edit_control_3();
2499 test_edit_control_4();
2500 test_edit_control_5();
2501 test_edit_control_6();
2502 test_edit_control_limittext();
2503 test_edit_control_scroll();
2504 test_margins();
2505 test_margins_font_change();
2506 test_text_position();
2507 test_espassword();
2508 test_undo();
2509 test_enter();
2510 test_tab();
2511 test_edit_dialog();
2512 test_multi_edit_dialog();
2513 test_wantreturn_edit_dialog();
2514 test_singleline_wantreturn_edit_dialog();
2515 test_child_edit_wmkeydown();
2516 test_fontsize();
2517 test_dialogmode();
2518 if (pEndMenu)
2519 test_contextmenu_focus();
2520 else
2521 win_skip("EndMenu is not available\n");
2522
2523 UnregisterWindowClasses();
2524 }
Windows API implementation