1 /*
2 * 16-bit windowing functions
3 *
4 * Copyright 2001 Alexandre Julliard
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 "wine/winuser16.h"
22 #include "wownt32.h"
23 #include "win.h"
24 #include "user_private.h"
25
26 /* handle <--> handle16 conversions */
27 #define HANDLE_16(h32) (LOWORD(h32))
28 #define HANDLE_32(h16) ((HANDLE)(ULONG_PTR)(h16))
29
30 static HWND16 hwndSysModal;
31
32 struct wnd_enum_info
33 {
34 WNDENUMPROC16 proc;
35 LPARAM param;
36 };
37
38 /* callback for 16-bit window enumeration functions */
39 static BOOL CALLBACK wnd_enum_callback( HWND hwnd, LPARAM param )
40 {
41 const struct wnd_enum_info *info = (struct wnd_enum_info *)param;
42 WORD args[3];
43 DWORD ret;
44
45 args[2] = HWND_16(hwnd);
46 args[1] = HIWORD(info->param);
47 args[0] = LOWORD(info->param);
48 WOWCallback16Ex( (DWORD)info->proc, WCB16_PASCAL, sizeof(args), args, &ret );
49 return LOWORD(ret);
50 }
51
52 /* convert insert after window handle to 32-bit */
53 static inline HWND full_insert_after_hwnd( HWND16 hwnd )
54 {
55 HWND ret = WIN_Handle32( hwnd );
56 if (ret == (HWND)0xffff) ret = HWND_TOPMOST;
57 return ret;
58 }
59
60 /**************************************************************************
61 * MessageBox (USER.1)
62 */
63 INT16 WINAPI MessageBox16( HWND16 hwnd, LPCSTR text, LPCSTR title, UINT16 type )
64 {
65 return MessageBoxA( WIN_Handle32(hwnd), text, title, type );
66 }
67
68
69 /***********************************************************************
70 * SetTimer (USER.10)
71 */
72 UINT16 WINAPI SetTimer16( HWND16 hwnd, UINT16 id, UINT16 timeout, TIMERPROC16 proc )
73 {
74 TIMERPROC proc32 = (TIMERPROC)WINPROC_AllocProc16( (WNDPROC16)proc );
75 return SetTimer( WIN_Handle32(hwnd), id, timeout, proc32 );
76 }
77
78
79 /***********************************************************************
80 * SetSystemTimer (USER.11)
81 */
82 UINT16 WINAPI SetSystemTimer16( HWND16 hwnd, UINT16 id, UINT16 timeout, TIMERPROC16 proc )
83 {
84 TIMERPROC proc32 = (TIMERPROC)WINPROC_AllocProc16( (WNDPROC16)proc );
85 return SetSystemTimer( WIN_Handle32(hwnd), id, timeout, proc32 );
86 }
87
88
89 /**************************************************************************
90 * KillTimer (USER.12)
91 */
92 BOOL16 WINAPI KillTimer16( HWND16 hwnd, UINT16 id )
93 {
94 return KillTimer( WIN_Handle32(hwnd), id );
95 }
96
97
98 /**************************************************************************
99 * SetCapture (USER.18)
100 */
101 HWND16 WINAPI SetCapture16( HWND16 hwnd )
102 {
103 return HWND_16( SetCapture( WIN_Handle32(hwnd) ));
104 }
105
106
107 /**************************************************************************
108 * ReleaseCapture (USER.19)
109 */
110 BOOL16 WINAPI ReleaseCapture16(void)
111 {
112 return ReleaseCapture();
113 }
114
115
116 /**************************************************************************
117 * SetFocus (USER.22)
118 */
119 HWND16 WINAPI SetFocus16( HWND16 hwnd )
120 {
121 return HWND_16( SetFocus( WIN_Handle32(hwnd) ));
122 }
123
124
125 /**************************************************************************
126 * GetFocus (USER.23)
127 */
128 HWND16 WINAPI GetFocus16(void)
129 {
130 return HWND_16( GetFocus() );
131 }
132
133
134 /**************************************************************************
135 * RemoveProp (USER.24)
136 */
137 HANDLE16 WINAPI RemoveProp16( HWND16 hwnd, LPCSTR str )
138 {
139 return HANDLE_16(RemovePropA( WIN_Handle32(hwnd), str ));
140 }
141
142
143 /**************************************************************************
144 * GetProp (USER.25)
145 */
146 HANDLE16 WINAPI GetProp16( HWND16 hwnd, LPCSTR str )
147 {
148 return HANDLE_16(GetPropA( WIN_Handle32(hwnd), str ));
149 }
150
151
152 /**************************************************************************
153 * SetProp (USER.26)
154 */
155 BOOL16 WINAPI SetProp16( HWND16 hwnd, LPCSTR str, HANDLE16 handle )
156 {
157 return SetPropA( WIN_Handle32(hwnd), str, HANDLE_32(handle) );
158 }
159
160
161 /**************************************************************************
162 * ClientToScreen (USER.28)
163 */
164 void WINAPI ClientToScreen16( HWND16 hwnd, LPPOINT16 lppnt )
165 {
166 MapWindowPoints16( hwnd, 0, lppnt, 1 );
167 }
168
169
170 /**************************************************************************
171 * ScreenToClient (USER.29)
172 */
173 void WINAPI ScreenToClient16( HWND16 hwnd, LPPOINT16 lppnt )
174 {
175 MapWindowPoints16( 0, hwnd, lppnt, 1 );
176 }
177
178
179 /**************************************************************************
180 * WindowFromPoint (USER.30)
181 */
182 HWND16 WINAPI WindowFromPoint16( POINT16 pt )
183 {
184 POINT pt32;
185
186 pt32.x = pt.x;
187 pt32.y = pt.y;
188 return HWND_16( WindowFromPoint( pt32 ) );
189 }
190
191
192 /**************************************************************************
193 * IsIconic (USER.31)
194 */
195 BOOL16 WINAPI IsIconic16(HWND16 hwnd)
196 {
197 return IsIconic( WIN_Handle32(hwnd) );
198 }
199
200
201 /**************************************************************************
202 * GetWindowRect (USER.32)
203 */
204 void WINAPI GetWindowRect16( HWND16 hwnd, LPRECT16 rect )
205 {
206 RECT rect32;
207
208 GetWindowRect( WIN_Handle32(hwnd), &rect32 );
209 rect->left = rect32.left;
210 rect->top = rect32.top;
211 rect->right = rect32.right;
212 rect->bottom = rect32.bottom;
213 }
214
215
216 /**************************************************************************
217 * GetClientRect (USER.33)
218 */
219 void WINAPI GetClientRect16( HWND16 hwnd, LPRECT16 rect )
220 {
221 RECT rect32;
222
223 GetClientRect( WIN_Handle32(hwnd), &rect32 );
224 rect->left = rect32.left;
225 rect->top = rect32.top;
226 rect->right = rect32.right;
227 rect->bottom = rect32.bottom;
228 }
229
230
231 /**************************************************************************
232 * EnableWindow (USER.34)
233 */
234 BOOL16 WINAPI EnableWindow16( HWND16 hwnd, BOOL16 enable )
235 {
236 return EnableWindow( WIN_Handle32(hwnd), enable );
237 }
238
239
240 /**************************************************************************
241 * IsWindowEnabled (USER.35)
242 */
243 BOOL16 WINAPI IsWindowEnabled16(HWND16 hwnd)
244 {
245 return IsWindowEnabled( WIN_Handle32(hwnd) );
246 }
247
248
249 /**************************************************************************
250 * GetWindowText (USER.36)
251 */
252 INT16 WINAPI GetWindowText16( HWND16 hwnd, SEGPTR lpString, INT16 nMaxCount )
253 {
254 return SendMessage16( hwnd, WM_GETTEXT, nMaxCount, lpString );
255 }
256
257
258 /**************************************************************************
259 * SetWindowText (USER.37)
260 */
261 BOOL16 WINAPI SetWindowText16( HWND16 hwnd, SEGPTR lpString )
262 {
263 return SendMessage16( hwnd, WM_SETTEXT, 0, (LPARAM)lpString );
264 }
265
266
267 /**************************************************************************
268 * GetWindowTextLength (USER.38)
269 */
270 INT16 WINAPI GetWindowTextLength16( HWND16 hwnd )
271 {
272 return SendMessage16( hwnd, WM_GETTEXTLENGTH, 0, 0 );
273 }
274
275
276 /***********************************************************************
277 * BeginPaint (USER.39)
278 */
279 HDC16 WINAPI BeginPaint16( HWND16 hwnd, LPPAINTSTRUCT16 lps )
280 {
281 PAINTSTRUCT ps;
282
283 BeginPaint( WIN_Handle32(hwnd), &ps );
284 lps->hdc = HDC_16(ps.hdc);
285 lps->fErase = ps.fErase;
286 lps->rcPaint.top = ps.rcPaint.top;
287 lps->rcPaint.left = ps.rcPaint.left;
288 lps->rcPaint.right = ps.rcPaint.right;
289 lps->rcPaint.bottom = ps.rcPaint.bottom;
290 lps->fRestore = ps.fRestore;
291 lps->fIncUpdate = ps.fIncUpdate;
292 return lps->hdc;
293 }
294
295
296 /***********************************************************************
297 * EndPaint (USER.40)
298 */
299 BOOL16 WINAPI EndPaint16( HWND16 hwnd, const PAINTSTRUCT16* lps )
300 {
301 PAINTSTRUCT ps;
302
303 ps.hdc = HDC_32(lps->hdc);
304 return EndPaint( WIN_Handle32(hwnd), &ps );
305 }
306
307
308 /**************************************************************************
309 * ShowWindow (USER.42)
310 */
311 BOOL16 WINAPI ShowWindow16( HWND16 hwnd, INT16 cmd )
312 {
313 return ShowWindow( WIN_Handle32(hwnd), cmd );
314 }
315
316
317 /**************************************************************************
318 * CloseWindow (USER.43)
319 */
320 BOOL16 WINAPI CloseWindow16( HWND16 hwnd )
321 {
322 return CloseWindow( WIN_Handle32(hwnd) );
323 }
324
325
326 /**************************************************************************
327 * OpenIcon (USER.44)
328 */
329 BOOL16 WINAPI OpenIcon16( HWND16 hwnd )
330 {
331 return OpenIcon( WIN_Handle32(hwnd) );
332 }
333
334
335 /**************************************************************************
336 * BringWindowToTop (USER.45)
337 */
338 BOOL16 WINAPI BringWindowToTop16( HWND16 hwnd )
339 {
340 return BringWindowToTop( WIN_Handle32(hwnd) );
341 }
342
343
344 /**************************************************************************
345 * GetParent (USER.46)
346 */
347 HWND16 WINAPI GetParent16( HWND16 hwnd )
348 {
349 return HWND_16( GetParent( WIN_Handle32(hwnd) ));
350 }
351
352
353 /**************************************************************************
354 * IsWindow (USER.47)
355 */
356 BOOL16 WINAPI IsWindow16( HWND16 hwnd )
357 {
358 STACK16FRAME *frame = MapSL( (SEGPTR)NtCurrentTeb()->WOW32Reserved );
359 frame->es = USER_HeapSel;
360 /* don't use WIN_Handle32 here, we don't care about the full handle */
361 return IsWindow( HWND_32(hwnd) );
362 }
363
364
365 /**************************************************************************
366 * IsChild (USER.48)
367 */
368 BOOL16 WINAPI IsChild16( HWND16 parent, HWND16 child )
369 {
370 return IsChild( WIN_Handle32(parent), WIN_Handle32(child) );
371 }
372
373
374 /**************************************************************************
375 * IsWindowVisible (USER.49)
376 */
377 BOOL16 WINAPI IsWindowVisible16( HWND16 hwnd )
378 {
379 return IsWindowVisible( WIN_Handle32(hwnd) );
380 }
381
382
383 /**************************************************************************
384 * FindWindow (USER.50)
385 */
386 HWND16 WINAPI FindWindow16( LPCSTR className, LPCSTR title )
387 {
388 return HWND_16( FindWindowA( className, title ));
389 }
390
391
392 /**************************************************************************
393 * DestroyWindow (USER.53)
394 */
395 BOOL16 WINAPI DestroyWindow16( HWND16 hwnd )
396 {
397 return DestroyWindow( WIN_Handle32(hwnd) );
398 }
399
400
401 /*******************************************************************
402 * EnumWindows (USER.54)
403 */
404 BOOL16 WINAPI EnumWindows16( WNDENUMPROC16 func, LPARAM lParam )
405 {
406 struct wnd_enum_info info;
407
408 info.proc = func;
409 info.param = lParam;
410 return EnumWindows( wnd_enum_callback, (LPARAM)&info );
411 }
412
413
414 /**********************************************************************
415 * EnumChildWindows (USER.55)
416 */
417 BOOL16 WINAPI EnumChildWindows16( HWND16 parent, WNDENUMPROC16 func, LPARAM lParam )
418 {
419 struct wnd_enum_info info;
420
421 info.proc = func;
422 info.param = lParam;
423 return EnumChildWindows( WIN_Handle32(parent), wnd_enum_callback, (LPARAM)&info );
424 }
425
426
427 /**************************************************************************
428 * MoveWindow (USER.56)
429 */
430 BOOL16 WINAPI MoveWindow16( HWND16 hwnd, INT16 x, INT16 y, INT16 cx, INT16 cy, BOOL16 repaint )
431 {
432 return MoveWindow( WIN_Handle32(hwnd), x, y, cx, cy, repaint );
433 }
434
435
436 /***********************************************************************
437 * RegisterClass (USER.57)
438 */
439 ATOM WINAPI RegisterClass16( const WNDCLASS16 *wc )
440 {
441 WNDCLASSEX16 wcex;
442
443 wcex.cbSize = sizeof(wcex);
444 wcex.style = wc->style;
445 wcex.lpfnWndProc = wc->lpfnWndProc;
446 wcex.cbClsExtra = wc->cbClsExtra;
447 wcex.cbWndExtra = wc->cbWndExtra;
448 wcex.hInstance = wc->hInstance;
449 wcex.hIcon = wc->hIcon;
450 wcex.hCursor = wc->hCursor;
451 wcex.hbrBackground = wc->hbrBackground;
452 wcex.lpszMenuName = wc->lpszMenuName;
453 wcex.lpszClassName = wc->lpszClassName;
454 wcex.hIconSm = 0;
455 return RegisterClassEx16( &wcex );
456 }
457
458
459 /**************************************************************************
460 * GetClassName (USER.58)
461 */
462 INT16 WINAPI GetClassName16( HWND16 hwnd, LPSTR buffer, INT16 count )
463 {
464 return GetClassNameA( WIN_Handle32(hwnd), buffer, count );
465 }
466
467
468 /**************************************************************************
469 * SetActiveWindow (USER.59)
470 */
471 HWND16 WINAPI SetActiveWindow16( HWND16 hwnd )
472 {
473 return HWND_16( SetActiveWindow( WIN_Handle32(hwnd) ));
474 }
475
476
477 /**************************************************************************
478 * GetActiveWindow (USER.60)
479 */
480 HWND16 WINAPI GetActiveWindow16(void)
481 {
482 return HWND_16( GetActiveWindow() );
483 }
484
485
486 /**************************************************************************
487 * ScrollWindow (USER.61)
488 */
489 void WINAPI ScrollWindow16( HWND16 hwnd, INT16 dx, INT16 dy, const RECT16 *rect,
490 const RECT16 *clipRect )
491 {
492 RECT rect32, clipRect32;
493
494 if (rect)
495 {
496 rect32.left = rect->left;
497 rect32.top = rect->top;
498 rect32.right = rect->right;
499 rect32.bottom = rect->bottom;
500 }
501 if (clipRect)
502 {
503 clipRect32.left = clipRect->left;
504 clipRect32.top = clipRect->top;
505 clipRect32.right = clipRect->right;
506 clipRect32.bottom = clipRect->bottom;
507 }
508 ScrollWindow( WIN_Handle32(hwnd), dx, dy, rect ? &rect32 : NULL,
509 clipRect ? &clipRect32 : NULL );
510 }
511
512
513 /**************************************************************************
514 * SetScrollPos (USER.62)
515 */
516 INT16 WINAPI SetScrollPos16( HWND16 hwnd, INT16 nBar, INT16 nPos, BOOL16 redraw )
517 {
518 return SetScrollPos( WIN_Handle32(hwnd), nBar, nPos, redraw );
519 }
520
521
522 /**************************************************************************
523 * GetScrollPos (USER.63)
524 */
525 INT16 WINAPI GetScrollPos16( HWND16 hwnd, INT16 nBar )
526 {
527 return GetScrollPos( WIN_Handle32(hwnd), nBar );
528 }
529
530
531 /**************************************************************************
532 * SetScrollRange (USER.64)
533 */
534 void WINAPI SetScrollRange16( HWND16 hwnd, INT16 nBar, INT16 MinVal, INT16 MaxVal, BOOL16 redraw )
535 {
536 /* Invalid range -> range is set to (0,0) */
537 if ((INT)MaxVal - (INT)MinVal > 0x7fff) MinVal = MaxVal = 0;
538 SetScrollRange( WIN_Handle32(hwnd), nBar, MinVal, MaxVal, redraw );
539 }
540
541
542 /**************************************************************************
543 * GetScrollRange (USER.65)
544 */
545 BOOL16 WINAPI GetScrollRange16( HWND16 hwnd, INT16 nBar, LPINT16 lpMin, LPINT16 lpMax)
546 {
547 INT min, max;
548 BOOL ret = GetScrollRange( WIN_Handle32(hwnd), nBar, &min, &max );
549 if (lpMin) *lpMin = min;
550 if (lpMax) *lpMax = max;
551 return ret;
552 }
553
554
555 /**************************************************************************
556 * GetDC (USER.66)
557 */
558 HDC16 WINAPI GetDC16( HWND16 hwnd )
559 {
560 return HDC_16(GetDC( WIN_Handle32(hwnd) ));
561 }
562
563
564 /**************************************************************************
565 * GetWindowDC (USER.67)
566 */
567 HDC16 WINAPI GetWindowDC16( HWND16 hwnd )
568 {
569 return GetDCEx16( hwnd, 0, DCX_USESTYLE | DCX_WINDOW );
570 }
571
572
573 /**************************************************************************
574 * ReleaseDC (USER.68)
575 */
576 INT16 WINAPI ReleaseDC16( HWND16 hwnd, HDC16 hdc )
577 {
578 return (INT16)ReleaseDC( WIN_Handle32(hwnd), HDC_32(hdc) );
579 }
580
581
582 /**************************************************************************
583 * FlashWindow (USER.105)
584 */
585 BOOL16 WINAPI FlashWindow16( HWND16 hwnd, BOOL16 bInvert )
586 {
587 return FlashWindow( WIN_Handle32(hwnd), bInvert );
588 }
589
590
591 /**************************************************************************
592 * WindowFromDC (USER.117)
593 */
594 HWND16 WINAPI WindowFromDC16( HDC16 hDC )
595 {
596 return HWND_16( WindowFromDC( HDC_32(hDC) ) );
597 }
598
599
600 /**************************************************************************
601 * UpdateWindow (USER.124)
602 */
603 void WINAPI UpdateWindow16( HWND16 hwnd )
604 {
605 RedrawWindow16( hwnd, NULL, 0, RDW_UPDATENOW | RDW_ALLCHILDREN );
606 }
607
608
609 /**************************************************************************
610 * InvalidateRect (USER.125)
611 */
612 void WINAPI InvalidateRect16( HWND16 hwnd, const RECT16 *rect, BOOL16 erase )
613 {
614 RedrawWindow16( hwnd, rect, 0, RDW_INVALIDATE | (erase ? RDW_ERASE : 0) );
615 }
616
617
618 /**************************************************************************
619 * InvalidateRgn (USER.126)
620 */
621 void WINAPI InvalidateRgn16( HWND16 hwnd, HRGN16 hrgn, BOOL16 erase )
622 {
623 RedrawWindow16( hwnd, NULL, hrgn, RDW_INVALIDATE | (erase ? RDW_ERASE : 0) );
624 }
625
626
627 /**************************************************************************
628 * ValidateRect (USER.127)
629 */
630 void WINAPI ValidateRect16( HWND16 hwnd, const RECT16 *rect )
631 {
632 RedrawWindow16( hwnd, rect, 0, RDW_VALIDATE | RDW_NOCHILDREN );
633 }
634
635
636 /**************************************************************************
637 * ValidateRgn (USER.128)
638 */
639 void WINAPI ValidateRgn16( HWND16 hwnd, HRGN16 hrgn )
640 {
641 RedrawWindow16( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOCHILDREN );
642 }
643
644
645 /**************************************************************************
646 * GetClassWord (USER.129)
647 */
648 WORD WINAPI GetClassWord16( HWND16 hwnd, INT16 offset )
649 {
650 return GetClassWord( WIN_Handle32(hwnd), offset );
651 }
652
653
654 /**************************************************************************
655 * SetClassWord (USER.130)
656 */
657 WORD WINAPI SetClassWord16( HWND16 hwnd, INT16 offset, WORD newval )
658 {
659 return SetClassWord( WIN_Handle32(hwnd), offset, newval );
660 }
661
662
663 /***********************************************************************
664 * GetClassLong (USER.131)
665 */
666 LONG WINAPI GetClassLong16( HWND16 hwnd16, INT16 offset )
667 {
668 LONG_PTR ret = GetClassLongA( WIN_Handle32(hwnd16), offset );
669
670 switch( offset )
671 {
672 case GCLP_WNDPROC:
673 return (LONG_PTR)WINPROC_GetProc16( (WNDPROC)ret, FALSE );
674 case GCLP_MENUNAME:
675 return MapLS( (void *)ret ); /* leak */
676 default:
677 return ret;
678 }
679 }
680
681
682 /***********************************************************************
683 * SetClassLong (USER.132)
684 */
685 LONG WINAPI SetClassLong16( HWND16 hwnd16, INT16 offset, LONG newval )
686 {
687 switch( offset )
688 {
689 case GCLP_WNDPROC:
690 {
691 WNDPROC new_proc = WINPROC_AllocProc16( (WNDPROC16)newval );
692 WNDPROC old_proc = (WNDPROC)SetClassLongA( WIN_Handle32(hwnd16), offset, (LONG_PTR)new_proc );
693 return (LONG)WINPROC_GetProc16( old_proc, FALSE );
694 }
695 case GCLP_MENUNAME:
696 newval = (LONG)MapSL( newval );
697 /* fall through */
698 default:
699 return SetClassLongA( WIN_Handle32(hwnd16), offset, newval );
700 }
701 }
702
703
704 /**************************************************************************
705 * GetWindowWord (USER.133)
706 */
707 WORD WINAPI GetWindowWord16( HWND16 hwnd, INT16 offset )
708 {
709 return GetWindowWord( WIN_Handle32(hwnd), offset );
710 }
711
712
713 /**************************************************************************
714 * SetWindowWord (USER.134)
715 */
716 WORD WINAPI SetWindowWord16( HWND16 hwnd, INT16 offset, WORD newval )
717 {
718 return SetWindowWord( WIN_Handle32(hwnd), offset, newval );
719 }
720
721
722 /**************************************************************************
723 * OpenClipboard (USER.137)
724 */
725 BOOL16 WINAPI OpenClipboard16( HWND16 hwnd )
726 {
727 return OpenClipboard( WIN_Handle32(hwnd) );
728 }
729
730
731 /**************************************************************************
732 * GetClipboardOwner (USER.140)
733 */
734 HWND16 WINAPI GetClipboardOwner16(void)
735 {
736 return HWND_16( GetClipboardOwner() );
737 }
738
739
740 /**************************************************************************
741 * SetClipboardViewer (USER.147)
742 */
743 HWND16 WINAPI SetClipboardViewer16( HWND16 hwnd )
744 {
745 return HWND_16( SetClipboardViewer( WIN_Handle32(hwnd) ));
746 }
747
748
749 /**************************************************************************
750 * GetClipboardViewer (USER.148)
751 */
752 HWND16 WINAPI GetClipboardViewer16(void)
753 {
754 return HWND_16( GetClipboardViewer() );
755 }
756
757
758 /**************************************************************************
759 * ChangeClipboardChain (USER.149)
760 */
761 BOOL16 WINAPI ChangeClipboardChain16(HWND16 hwnd, HWND16 hwndNext)
762 {
763 return ChangeClipboardChain( WIN_Handle32(hwnd), WIN_Handle32(hwndNext) );
764 }
765
766
767 /**************************************************************************
768 * GetSystemMenu (USER.156)
769 */
770 HMENU16 WINAPI GetSystemMenu16( HWND16 hwnd, BOOL16 revert )
771 {
772 return HMENU_16(GetSystemMenu( WIN_Handle32(hwnd), revert ));
773 }
774
775
776 /**************************************************************************
777 * GetMenu (USER.157)
778 */
779 HMENU16 WINAPI GetMenu16( HWND16 hwnd )
780 {
781 return HMENU_16(GetMenu( WIN_Handle32(hwnd) ));
782 }
783
784
785 /**************************************************************************
786 * SetMenu (USER.158)
787 */
788 BOOL16 WINAPI SetMenu16( HWND16 hwnd, HMENU16 hMenu )
789 {
790 return SetMenu( WIN_Handle32(hwnd), HMENU_32(hMenu) );
791 }
792
793
794 /**************************************************************************
795 * DrawMenuBar (USER.160)
796 */
797 void WINAPI DrawMenuBar16( HWND16 hwnd )
798 {
799 DrawMenuBar( WIN_Handle32(hwnd) );
800 }
801
802
803 /**************************************************************************
804 * HiliteMenuItem (USER.162)
805 */
806 BOOL16 WINAPI HiliteMenuItem16( HWND16 hwnd, HMENU16 hMenu, UINT16 id, UINT16 wHilite )
807 {
808 return HiliteMenuItem( WIN_Handle32(hwnd), HMENU_32(hMenu), id, wHilite );
809 }
810
811
812 /**************************************************************************
813 * CreateCaret (USER.163)
814 */
815 void WINAPI CreateCaret16( HWND16 hwnd, HBITMAP16 bitmap, INT16 width, INT16 height )
816 {
817 CreateCaret( WIN_Handle32(hwnd), HBITMAP_32(bitmap), width, height );
818 }
819
820
821 /*****************************************************************
822 * DestroyCaret (USER.164)
823 */
824 void WINAPI DestroyCaret16(void)
825 {
826 DestroyCaret();
827 }
828
829
830 /*****************************************************************
831 * SetCaretPos (USER.165)
832 */
833 void WINAPI SetCaretPos16( INT16 x, INT16 y )
834 {
835 SetCaretPos( x, y );
836 }
837
838
839 /**************************************************************************
840 * HideCaret (USER.166)
841 */
842 void WINAPI HideCaret16( HWND16 hwnd )
843 {
844 HideCaret( WIN_Handle32(hwnd) );
845 }
846
847
848 /**************************************************************************
849 * ShowCaret (USER.167)
850 */
851 void WINAPI ShowCaret16( HWND16 hwnd )
852 {
853 ShowCaret( WIN_Handle32(hwnd) );
854 }
855
856
857 /*****************************************************************
858 * SetCaretBlinkTime (USER.168)
859 */
860 void WINAPI SetCaretBlinkTime16( UINT16 msecs )
861 {
862 SetCaretBlinkTime( msecs );
863 }
864
865
866 /*****************************************************************
867 * GetCaretBlinkTime (USER.169)
868 */
869 UINT16 WINAPI GetCaretBlinkTime16(void)
870 {
871 return GetCaretBlinkTime();
872 }
873
874
875 /**************************************************************************
876 * ArrangeIconicWindows (USER.170)
877 */
878 UINT16 WINAPI ArrangeIconicWindows16( HWND16 parent)
879 {
880 return ArrangeIconicWindows( WIN_Handle32(parent) );
881 }
882
883
884 /**************************************************************************
885 * SwitchToThisWindow (USER.172)
886 */
887 void WINAPI SwitchToThisWindow16( HWND16 hwnd, BOOL16 restore )
888 {
889 SwitchToThisWindow( WIN_Handle32(hwnd), restore );
890 }
891
892
893 /**************************************************************************
894 * KillSystemTimer (USER.182)
895 */
896 BOOL16 WINAPI KillSystemTimer16( HWND16 hwnd, UINT16 id )
897 {
898 return KillSystemTimer( WIN_Handle32(hwnd), id );
899 }
900
901
902 /*****************************************************************
903 * GetCaretPos (USER.183)
904 */
905 void WINAPI GetCaretPos16( LPPOINT16 pt16 )
906 {
907 POINT pt;
908 if (GetCaretPos( &pt ))
909 {
910 pt16->x = pt.x;
911 pt16->y = pt.y;
912 }
913 }
914
915
916 /**************************************************************************
917 * SetSysModalWindow (USER.188)
918 */
919 HWND16 WINAPI SetSysModalWindow16( HWND16 hwnd )
920 {
921 HWND16 old = hwndSysModal;
922 hwndSysModal = hwnd;
923 return old;
924 }
925
926
927 /**************************************************************************
928 * GetSysModalWindow (USER.189)
929 */
930 HWND16 WINAPI GetSysModalWindow16(void)
931 {
932 return hwndSysModal;
933 }
934
935
936 /**************************************************************************
937 * GetUpdateRect (USER.190)
938 */
939 BOOL16 WINAPI GetUpdateRect16( HWND16 hwnd, LPRECT16 rect, BOOL16 erase )
940 {
941 RECT r;
942 BOOL16 ret;
943
944 if (!rect) return GetUpdateRect( WIN_Handle32(hwnd), NULL, erase );
945 ret = GetUpdateRect( WIN_Handle32(hwnd), &r, erase );
946 rect->left = r.left;
947 rect->top = r.top;
948 rect->right = r.right;
949 rect->bottom = r.bottom;
950 return ret;
951 }
952
953
954 /**************************************************************************
955 * ChildWindowFromPoint (USER.191)
956 */
957 HWND16 WINAPI ChildWindowFromPoint16( HWND16 hwndParent, POINT16 pt )
958 {
959 POINT pt32;
960
961 pt32.x = pt.x;
962 pt32.y = pt.y;
963 return HWND_16( ChildWindowFromPoint( WIN_Handle32(hwndParent), pt32 ));
964 }
965
966
967 /***********************************************************************
968 * CascadeChildWindows (USER.198)
969 */
970 void WINAPI CascadeChildWindows16( HWND16 parent, WORD action )
971 {
972 CascadeWindows( WIN_Handle32(parent), action, NULL, 0, NULL );
973 }
974
975
976 /***********************************************************************
977 * TileChildWindows (USER.199)
978 */
979 void WINAPI TileChildWindows16( HWND16 parent, WORD action )
980 {
981 TileWindows( WIN_Handle32(parent), action, NULL, 0, NULL );
982 }
983
984
985 /***********************************************************************
986 * GetWindowTask (USER.224)
987 */
988 HTASK16 WINAPI GetWindowTask16( HWND16 hwnd )
989 {
990 DWORD tid = GetWindowThreadProcessId( HWND_32(hwnd), NULL );
991 if (!tid) return 0;
992 return HTASK_16(tid);
993 }
994
995 /**********************************************************************
996 * EnumTaskWindows (USER.225)
997 */
998 BOOL16 WINAPI EnumTaskWindows16( HTASK16 hTask, WNDENUMPROC16 func, LPARAM lParam )
999 {
1000 struct wnd_enum_info info;
1001 DWORD tid = HTASK_32( hTask );
1002
1003 if (!tid) return FALSE;
1004 info.proc = func;
1005 info.param = lParam;
1006 return EnumThreadWindows( tid, wnd_enum_callback, (LPARAM)&info );
1007 }
1008
1009
1010 /**************************************************************************
1011 * GetTopWindow (USER.229)
1012 */
1013 HWND16 WINAPI GetTopWindow16( HWND16 hwnd )
1014 {
1015 return HWND_16( GetTopWindow( WIN_Handle32(hwnd) ));
1016 }
1017
1018
1019 /**************************************************************************
1020 * GetNextWindow (USER.230)
1021 */
1022 HWND16 WINAPI GetNextWindow16( HWND16 hwnd, WORD flag )
1023 {
1024 if ((flag != GW_HWNDNEXT) && (flag != GW_HWNDPREV)) return 0;
1025 return GetWindow16( hwnd, flag );
1026 }
1027
1028
1029 /**************************************************************************
1030 * SetWindowPos (USER.232)
1031 */
1032 BOOL16 WINAPI SetWindowPos16( HWND16 hwnd, HWND16 hwndInsertAfter,
1033 INT16 x, INT16 y, INT16 cx, INT16 cy, WORD flags)
1034 {
1035 return SetWindowPos( WIN_Handle32(hwnd), full_insert_after_hwnd(hwndInsertAfter),
1036 x, y, cx, cy, flags );
1037 }
1038
1039
1040 /**************************************************************************
1041 * SetParent (USER.233)
1042 */
1043 HWND16 WINAPI SetParent16( HWND16 hwndChild, HWND16 hwndNewParent )
1044 {
1045 return HWND_16( SetParent( WIN_Handle32(hwndChild), WIN_Handle32(hwndNewParent) ));
1046 }
1047
1048
1049 /**************************************************************************
1050 * GetCapture (USER.236)
1051 */
1052 HWND16 WINAPI GetCapture16(void)
1053 {
1054 return HWND_16( GetCapture() );
1055 }
1056
1057
1058 /**************************************************************************
1059 * GetUpdateRgn (USER.237)
1060 */
1061 INT16 WINAPI GetUpdateRgn16( HWND16 hwnd, HRGN16 hrgn, BOOL16 erase )
1062 {
1063 return GetUpdateRgn( WIN_Handle32(hwnd), HRGN_32(hrgn), erase );
1064 }
1065
1066
1067 /**************************************************************************
1068 * ExcludeUpdateRgn (USER.238)
1069 */
1070 INT16 WINAPI ExcludeUpdateRgn16( HDC16 hdc, HWND16 hwnd )
1071 {
1072 return ExcludeUpdateRgn( HDC_32(hdc), WIN_Handle32(hwnd) );
1073 }
1074
1075
1076 /**************************************************************************
1077 * GetOpenClipboardWindow (USER.248)
1078 */
1079 HWND16 WINAPI GetOpenClipboardWindow16(void)
1080 {
1081 return HWND_16( GetOpenClipboardWindow() );
1082 }
1083
1084
1085 /**************************************************************************
1086 * BeginDeferWindowPos (USER.259)
1087 */
1088 HDWP16 WINAPI BeginDeferWindowPos16( INT16 count )
1089 {
1090 return HDWP_16(BeginDeferWindowPos( count ));
1091 }
1092
1093
1094 /**************************************************************************
1095 * DeferWindowPos (USER.260)
1096 */
1097 HDWP16 WINAPI DeferWindowPos16( HDWP16 hdwp, HWND16 hwnd, HWND16 hwndAfter,
1098 INT16 x, INT16 y, INT16 cx, INT16 cy,
1099 UINT16 flags )
1100 {
1101 return HDWP_16(DeferWindowPos( HDWP_32(hdwp), WIN_Handle32(hwnd),
1102 full_insert_after_hwnd(hwndAfter), x, y, cx, cy, flags ));
1103 }
1104
1105
1106 /**************************************************************************
1107 * EndDeferWindowPos (USER.261)
1108 */
1109 BOOL16 WINAPI EndDeferWindowPos16( HDWP16 hdwp )
1110 {
1111 return EndDeferWindowPos(HDWP_32(hdwp));
1112 }
1113
1114
1115 /**************************************************************************
1116 * GetWindow (USER.262)
1117 */
1118 HWND16 WINAPI GetWindow16( HWND16 hwnd, WORD rel )
1119 {
1120 return HWND_16( GetWindow( WIN_Handle32(hwnd), rel ) );
1121 }
1122
1123
1124 /**************************************************************************
1125 * ShowOwnedPopups (USER.265)
1126 */
1127 void WINAPI ShowOwnedPopups16( HWND16 owner, BOOL16 fShow )
1128 {
1129 ShowOwnedPopups( WIN_Handle32(owner), fShow );
1130 }
1131
1132
1133 /**************************************************************************
1134 * ShowScrollBar (USER.267)
1135 */
1136 void WINAPI ShowScrollBar16( HWND16 hwnd, INT16 nBar, BOOL16 fShow )
1137 {
1138 ShowScrollBar( WIN_Handle32(hwnd), nBar, fShow );
1139 }
1140
1141
1142 /**************************************************************************
1143 * IsZoomed (USER.272)
1144 */
1145 BOOL16 WINAPI IsZoomed16(HWND16 hwnd)
1146 {
1147 return IsZoomed( WIN_Handle32(hwnd) );
1148 }
1149
1150
1151 /**************************************************************************
1152 * GetDlgCtrlID (USER.277)
1153 */
1154 INT16 WINAPI GetDlgCtrlID16( HWND16 hwnd )
1155 {
1156 return GetDlgCtrlID( WIN_Handle32(hwnd) );
1157 }
1158
1159
1160 /**************************************************************************
1161 * GetDesktopHwnd (USER.278)
1162 *
1163 * Exactly the same thing as GetDesktopWindow(), but not documented.
1164 * Don't ask me why...
1165 */
1166 HWND16 WINAPI GetDesktopHwnd16(void)
1167 {
1168 return GetDesktopWindow16();
1169 }
1170
1171
1172 /**************************************************************************
1173 * SetSystemMenu (USER.280)
1174 */
1175 BOOL16 WINAPI SetSystemMenu16( HWND16 hwnd, HMENU16 hMenu )
1176 {
1177 return SetSystemMenu( WIN_Handle32(hwnd), HMENU_32(hMenu) );
1178 }
1179
1180
1181 /**************************************************************************
1182 * GetDesktopWindow (USER.286)
1183 */
1184 HWND16 WINAPI GetDesktopWindow16(void)
1185 {
1186 return HWND_16( GetDesktopWindow() );
1187 }
1188
1189
1190 /**************************************************************************
1191 * GetLastActivePopup (USER.287)
1192 */
1193 HWND16 WINAPI GetLastActivePopup16( HWND16 hwnd )
1194 {
1195 return HWND_16( GetLastActivePopup( WIN_Handle32(hwnd) ));
1196 }
1197
1198
1199 /**************************************************************************
1200 * RedrawWindow (USER.290)
1201 */
1202 BOOL16 WINAPI RedrawWindow16( HWND16 hwnd, const RECT16 *rectUpdate,
1203 HRGN16 hrgnUpdate, UINT16 flags )
1204 {
1205 if (rectUpdate)
1206 {
1207 RECT r;
1208 r.left = rectUpdate->left;
1209 r.top = rectUpdate->top;
1210 r.right = rectUpdate->right;
1211 r.bottom = rectUpdate->bottom;
1212 return RedrawWindow(WIN_Handle32(hwnd), &r, HRGN_32(hrgnUpdate), flags);
1213 }
1214 return RedrawWindow(WIN_Handle32(hwnd), NULL, HRGN_32(hrgnUpdate), flags);
1215 }
1216
1217
1218 /**************************************************************************
1219 * LockWindowUpdate (USER.294)
1220 */
1221 BOOL16 WINAPI LockWindowUpdate16( HWND16 hwnd )
1222 {
1223 return LockWindowUpdate( WIN_Handle32(hwnd) );
1224 }
1225
1226
1227 /**************************************************************************
1228 * ScrollWindowEx (USER.319)
1229 */
1230 INT16 WINAPI ScrollWindowEx16( HWND16 hwnd, INT16 dx, INT16 dy,
1231 const RECT16 *rect, const RECT16 *clipRect,
1232 HRGN16 hrgnUpdate, LPRECT16 rcUpdate,
1233 UINT16 flags )
1234 {
1235 RECT rect32, clipRect32, rcUpdate32;
1236 BOOL16 ret;
1237
1238 if (rect)
1239 {
1240 rect32.left = rect->left;
1241 rect32.top = rect->top;
1242 rect32.right = rect->right;
1243 rect32.bottom = rect->bottom;
1244 }
1245 if (clipRect)
1246 {
1247 clipRect32.left = clipRect->left;
1248 clipRect32.top = clipRect->top;
1249 clipRect32.right = clipRect->right;
1250 clipRect32.bottom = clipRect->bottom;
1251 }
1252 ret = ScrollWindowEx( WIN_Handle32(hwnd), dx, dy, rect ? &rect32 : NULL,
1253 clipRect ? &clipRect32 : NULL, HRGN_32(hrgnUpdate),
1254 (rcUpdate) ? &rcUpdate32 : NULL, flags );
1255 if (rcUpdate)
1256 {
1257 rcUpdate->left = rcUpdate32.left;
1258 rcUpdate->top = rcUpdate32.top;
1259 rcUpdate->right = rcUpdate32.right;
1260 rcUpdate->bottom = rcUpdate32.bottom;
1261 }
1262 return ret;
1263 }
1264
1265
1266 /**************************************************************************
1267 * FillWindow (USER.324)
1268 */
1269 void WINAPI FillWindow16( HWND16 hwndParent, HWND16 hwnd, HDC16 hdc, HBRUSH16 hbrush )
1270 {
1271 RECT rect;
1272 RECT16 rc16;
1273 GetClientRect( WIN_Handle32(hwnd), &rect );
1274 DPtoLP( HDC_32(hdc), (LPPOINT)&rect, 2 );
1275 rc16.left = rect.left;
1276 rc16.top = rect.top;
1277 rc16.right = rect.right;
1278 rc16.bottom = rect.bottom;
1279 PaintRect16( hwndParent, hwnd, hdc, hbrush, &rc16 );
1280 }
1281
1282
1283 /**************************************************************************
1284 * PaintRect (USER.325)
1285 */
1286 void WINAPI PaintRect16( HWND16 hwndParent, HWND16 hwnd, HDC16 hdc,
1287 HBRUSH16 hbrush, const RECT16 *rect)
1288 {
1289 if (hbrush <= CTLCOLOR_STATIC)
1290 {
1291 HWND parent = WIN_Handle32(hwndParent), hwnd32 = WIN_Handle32(hwnd);
1292
1293 if (!parent) return;
1294 hbrush = SendMessageW( parent, WM_CTLCOLORMSGBOX + hbrush, (WPARAM)hdc, (LPARAM)hwnd32 );
1295 if (!hbrush) hbrush = DefWindowProcW( parent, WM_CTLCOLORMSGBOX + hbrush,
1296 (WPARAM)hdc, (LPARAM)hwnd32 );
1297 }
1298 if (hbrush) FillRect16( hdc, rect, hbrush );
1299 }
1300
1301
1302 /**************************************************************************
1303 * GetControlBrush (USER.326)
1304 */
1305 HBRUSH16 WINAPI GetControlBrush16( HWND16 hwnd, HDC16 hdc, UINT16 ctlType )
1306 {
1307 HBRUSH16 ret;
1308 HWND hwnd32 = WIN_Handle32(hwnd);
1309 HWND parent = GetParent( hwnd32 );
1310
1311 if (!parent) parent = hwnd32;
1312 ret = SendMessageW( parent, WM_CTLCOLORMSGBOX + ctlType, (WPARAM)hdc, (LPARAM)hwnd32 );
1313 if (!ret) ret = DefWindowProcW( parent, WM_CTLCOLORMSGBOX + ctlType,
1314 (WPARAM)hdc, (LPARAM)hwnd32 );
1315 return ret;
1316 }
1317
1318
1319 /**************************************************************************
1320 * GetDCEx (USER.359)
1321 */
1322 HDC16 WINAPI GetDCEx16( HWND16 hwnd, HRGN16 hrgnClip, DWORD flags )
1323 {
1324 return HDC_16(GetDCEx(WIN_Handle32(hwnd), HRGN_32(hrgnClip), flags));
1325 }
1326
1327
1328 /**************************************************************************
1329 * GetWindowPlacement (USER.370)
1330 */
1331 BOOL16 WINAPI GetWindowPlacement16( HWND16 hwnd, WINDOWPLACEMENT16 *wp16 )
1332 {
1333 WINDOWPLACEMENT wpl;
1334
1335 wpl.length = sizeof(wpl);
1336 if (!GetWindowPlacement( WIN_Handle32(hwnd), &wpl )) return FALSE;
1337 wp16->length = sizeof(*wp16);
1338 wp16->flags = wpl.flags;
1339 wp16->showCmd = wpl.showCmd;
1340 wp16->ptMinPosition.x = wpl.ptMinPosition.x;
1341 wp16->ptMinPosition.y = wpl.ptMinPosition.y;
1342 wp16->ptMaxPosition.x = wpl.ptMaxPosition.x;
1343 wp16->ptMaxPosition.y = wpl.ptMaxPosition.y;
1344 wp16->rcNormalPosition.left = wpl.rcNormalPosition.left;
1345 wp16->rcNormalPosition.top = wpl.rcNormalPosition.top;
1346 wp16->rcNormalPosition.right = wpl.rcNormalPosition.right;
1347 wp16->rcNormalPosition.bottom = wpl.rcNormalPosition.bottom;
1348 return TRUE;
1349 }
1350
1351
1352 /**************************************************************************
1353 * SetWindowPlacement (USER.371)
1354 */
1355 BOOL16 WINAPI SetWindowPlacement16( HWND16 hwnd, const WINDOWPLACEMENT16 *wp16 )
1356 {
1357 WINDOWPLACEMENT wpl;
1358
1359 if (!wp16) return FALSE;
1360 wpl.length = sizeof(wpl);
1361 wpl.flags = wp16->flags;
1362 wpl.showCmd = wp16->showCmd;
1363 wpl.ptMinPosition.x = wp16->ptMinPosition.x;
1364 wpl.ptMinPosition.y = wp16->ptMinPosition.y;
1365 wpl.ptMaxPosition.x = wp16->ptMaxPosition.x;
1366 wpl.ptMaxPosition.y = wp16->ptMaxPosition.y;
1367 wpl.rcNormalPosition.left = wp16->rcNormalPosition.left;
1368 wpl.rcNormalPosition.top = wp16->rcNormalPosition.top;
1369 wpl.rcNormalPosition.right = wp16->rcNormalPosition.right;
1370 wpl.rcNormalPosition.bottom = wp16->rcNormalPosition.bottom;
1371 return SetWindowPlacement( WIN_Handle32(hwnd), &wpl );
1372 }
1373
1374
1375 /***********************************************************************
1376 * RegisterClassEx (USER.397)
1377 */
1378 ATOM WINAPI RegisterClassEx16( const WNDCLASSEX16 *wc )
1379 {
1380 WNDCLASSEXA wc32;
1381
1382 wc32.cbSize = sizeof(wc32);
1383 wc32.style = wc->style;
1384 wc32.lpfnWndProc = WINPROC_AllocProc16( wc->lpfnWndProc );
1385 wc32.cbClsExtra = wc->cbClsExtra;
1386 wc32.cbWndExtra = wc->cbWndExtra;
1387 wc32.hInstance = HINSTANCE_32(GetExePtr(wc->hInstance));
1388 if (!wc32.hInstance) wc32.hInstance = HINSTANCE_32(GetModuleHandle16(NULL));
1389 wc32.hIcon = HICON_32(wc->hIcon);
1390 wc32.hCursor = HCURSOR_32(wc->hCursor);
1391 wc32.hbrBackground = HBRUSH_32(wc->hbrBackground);
1392 wc32.lpszMenuName = MapSL(wc->lpszMenuName);
1393 wc32.lpszClassName = MapSL(wc->lpszClassName);
1394 wc32.hIconSm = HICON_32(wc->hIconSm);
1395 return RegisterClassExA( &wc32 );
1396 }
1397
1398
1399 /***********************************************************************
1400 * GetClassInfoEx (USER.398)
1401 *
1402 * FIXME: this is just a guess, I have no idea if GetClassInfoEx() is the
1403 * same in Win16 as in Win32. --AJ
1404 */
1405 BOOL16 WINAPI GetClassInfoEx16( HINSTANCE16 hInst16, SEGPTR name, WNDCLASSEX16 *wc )
1406 {
1407 WNDCLASSEXA wc32;
1408 HINSTANCE hInstance;
1409 BOOL ret;
1410
1411 if (hInst16 == GetModuleHandle16("user")) hInstance = user32_module;
1412 else hInstance = HINSTANCE_32(GetExePtr( hInst16 ));
1413
1414 ret = GetClassInfoExA( hInstance, MapSL(name), &wc32 );
1415
1416 if (ret)
1417 {
1418 wc->lpfnWndProc = WINPROC_GetProc16( wc32.lpfnWndProc, FALSE );
1419 wc->style = wc32.style;
1420 wc->cbClsExtra = wc32.cbClsExtra;
1421 wc->cbWndExtra = wc32.cbWndExtra;
1422 wc->hInstance = (wc32.hInstance == user32_module) ? GetModuleHandle16("user") : HINSTANCE_16(wc32.hInstance);
1423 wc->hIcon = HICON_16(wc32.hIcon);
1424 wc->hIconSm = HICON_16(wc32.hIconSm);
1425 wc->hCursor = HCURSOR_16(wc32.hCursor);
1426 wc->hbrBackground = HBRUSH_16(wc32.hbrBackground);
1427 wc->lpszClassName = 0;
1428 wc->lpszMenuName = MapLS(wc32.lpszMenuName); /* FIXME: leak */
1429 }
1430 return ret;
1431 }
1432
1433
1434 /**************************************************************************
1435 * ChildWindowFromPointEx (USER.399)
1436 */
1437 HWND16 WINAPI ChildWindowFromPointEx16( HWND16 hwndParent, POINT16 pt, UINT16 uFlags)
1438 {
1439 POINT pt32;
1440
1441 pt32.x = pt.x;
1442 pt32.y = pt.y;
1443 return HWND_16( ChildWindowFromPointEx( WIN_Handle32(hwndParent), pt32, uFlags ));
1444 }
1445
1446
1447 /**************************************************************************
1448 * GetPriorityClipboardFormat (USER.402)
1449 */
1450 INT16 WINAPI GetPriorityClipboardFormat16( UINT16 *list, INT16 count )
1451 {
1452 int i;
1453
1454 for (i = 0; i < count; i++)
1455 if (IsClipboardFormatAvailable( list[i] )) return list[i];
1456 return -1;
1457 }
1458
1459
1460 /***********************************************************************
1461 * UnregisterClass (USER.403)
1462 */
1463 BOOL16 WINAPI UnregisterClass16( LPCSTR className, HINSTANCE16 hInstance )
1464 {
1465 if (hInstance == GetModuleHandle16("user")) hInstance = 0;
1466 return UnregisterClassA( className, HINSTANCE_32(GetExePtr( hInstance )) );
1467 }
1468
1469
1470 /***********************************************************************
1471 * GetClassInfo (USER.404)
1472 */
1473 BOOL16 WINAPI GetClassInfo16( HINSTANCE16 hInst16, SEGPTR name, WNDCLASS16 *wc )
1474 {
1475 WNDCLASSEX16 wcex;
1476 UINT16 ret = GetClassInfoEx16( hInst16, name, &wcex );
1477
1478 if (ret)
1479 {
1480 wc->style = wcex.style;
1481 wc->lpfnWndProc = wcex.lpfnWndProc;
1482 wc->cbClsExtra = wcex.cbClsExtra;
1483 wc->cbWndExtra = wcex.cbWndExtra;
1484 wc->hInstance = wcex.hInstance;
1485 wc->hIcon = wcex.hIcon;
1486 wc->hCursor = wcex.hCursor;
1487 wc->hbrBackground = wcex.hbrBackground;
1488 wc->lpszMenuName = wcex.lpszMenuName;
1489 wc->lpszClassName = wcex.lpszClassName;
1490 }
1491 return ret;
1492 }
1493
1494
1495 /**************************************************************************
1496 * TrackPopupMenu (USER.416)
1497 */
1498 BOOL16 WINAPI TrackPopupMenu16( HMENU16 hMenu, UINT16 wFlags, INT16 x, INT16 y,
1499 INT16 nReserved, HWND16 hwnd, const RECT16 *lpRect )
1500 {
1501 RECT r;
1502 if (lpRect)
1503 {
1504 r.left = lpRect->left;
1505 r.top = lpRect->top;
1506 r.right = lpRect->right;
1507 r.bottom = lpRect->bottom;
1508 }
1509 return TrackPopupMenu( HMENU_32(hMenu), wFlags, x, y, nReserved,
1510 WIN_Handle32(hwnd), lpRect ? &r : NULL );
1511 }
1512
1513
1514 /**************************************************************************
1515 * FindWindowEx (USER.427)
1516 */
1517 HWND16 WINAPI FindWindowEx16( HWND16 parent, HWND16 child, LPCSTR className, LPCSTR title )
1518 {
1519 return HWND_16( FindWindowExA( WIN_Handle32(parent), WIN_Handle32(child),
1520 className, title ));
1521 }
1522
1523
1524 /***********************************************************************
1525 * DefFrameProc (USER.445)
1526 */
1527 LRESULT WINAPI DefFrameProc16( HWND16 hwnd, HWND16 hwndMDIClient,
1528 UINT16 message, WPARAM16 wParam, LPARAM lParam )
1529 {
1530 switch (message)
1531 {
1532 case WM_SETTEXT:
1533 lParam = (LPARAM)MapSL(lParam);
1534 /* fall through */
1535 case WM_COMMAND:
1536 case WM_NCACTIVATE:
1537 case WM_SETFOCUS:
1538 case WM_SIZE:
1539 return DefFrameProcA( WIN_Handle32(hwnd), WIN_Handle32(hwndMDIClient),
1540 message, wParam, lParam );
1541
1542 case WM_NEXTMENU:
1543 {
1544 MDINEXTMENU next_menu;
1545 DefFrameProcW( WIN_Handle32(hwnd), WIN_Handle32(hwndMDIClient),
1546 message, wParam, (LPARAM)&next_menu );
1547 return MAKELONG( HMENU_16(next_menu.hmenuNext), HWND_16(next_menu.hwndNext) );
1548 }
1549 default:
1550 return DefWindowProc16(hwnd, message, wParam, lParam);
1551 }
1552 }
1553
1554
1555 /***********************************************************************
1556 * DefMDIChildProc (USER.447)
1557 */
1558 LRESULT WINAPI DefMDIChildProc16( HWND16 hwnd, UINT16 message,
1559 WPARAM16 wParam, LPARAM lParam )
1560 {
1561 switch (message)
1562 {
1563 case WM_SETTEXT:
1564 return DefMDIChildProcA( WIN_Handle32(hwnd), message, wParam, (LPARAM)MapSL(lParam) );
1565
1566 case WM_MENUCHAR:
1567 case WM_CLOSE:
1568 case WM_SETFOCUS:
1569 case WM_CHILDACTIVATE:
1570 case WM_SYSCOMMAND:
1571 case WM_SETVISIBLE:
1572 case WM_SIZE:
1573 case WM_SYSCHAR:
1574 return DefMDIChildProcW( WIN_Handle32(hwnd), message, wParam, lParam );
1575
1576 case WM_GETMINMAXINFO:
1577 {
1578 MINMAXINFO16 *mmi16 = MapSL(lParam);
1579 MINMAXINFO mmi;
1580
1581 mmi.ptReserved.x = mmi16->ptReserved.x;
1582 mmi.ptReserved.y = mmi16->ptReserved.y;
1583 mmi.ptMaxSize.x = mmi16->ptMaxSize.x;
1584 mmi.ptMaxSize.y = mmi16->ptMaxSize.y;
1585 mmi.ptMaxPosition.x = mmi16->ptMaxPosition.x;
1586 mmi.ptMaxPosition.y = mmi16->ptMaxPosition.y;
1587 mmi.ptMinTrackSize.x = mmi16->ptMinTrackSize.x;
1588 mmi.ptMinTrackSize.y = mmi16->ptMinTrackSize.y;
1589 mmi.ptMaxTrackSize.x = mmi16->ptMaxTrackSize.x;
1590 mmi.ptMaxTrackSize.y = mmi16->ptMaxTrackSize.y;
1591
1592 DefMDIChildProcW( WIN_Handle32(hwnd), message, wParam, (LPARAM)&mmi );
1593
1594 mmi16->ptReserved.x = mmi.ptReserved.x;
1595 mmi16->ptReserved.y = mmi.ptReserved.y;
1596 mmi16->ptMaxSize.x = mmi.ptMaxSize.x;
1597 mmi16->ptMaxSize.y = mmi.ptMaxSize.y;
1598 mmi16->ptMaxPosition.x = mmi.ptMaxPosition.x;
1599 mmi16->ptMaxPosition.y = mmi.ptMaxPosition.y;
1600 mmi16->ptMinTrackSize.x = mmi.ptMinTrackSize.x;
1601 mmi16->ptMinTrackSize.y = mmi.ptMinTrackSize.y;
1602 mmi16->ptMaxTrackSize.x = mmi.ptMaxTrackSize.x;
1603 mmi16->ptMaxTrackSize.y = mmi.ptMaxTrackSize.y;
1604 return 0;
1605 }
1606 case WM_NEXTMENU:
1607 {
1608 MDINEXTMENU next_menu;
1609 DefMDIChildProcW( WIN_Handle32(hwnd), message, wParam, (LPARAM)&next_menu );
1610 return MAKELONG( HMENU_16(next_menu.hmenuNext), HWND_16(next_menu.hwndNext) );
1611 }
1612 default:
1613 return DefWindowProc16(hwnd, message, wParam, lParam);
1614 }
1615 }
1616
1617
1618 /**************************************************************************
1619 * DrawAnimatedRects (USER.448)
1620 */
1621 BOOL16 WINAPI DrawAnimatedRects16( HWND16 hwnd, INT16 idAni,
1622 const RECT16* lprcFrom, const RECT16* lprcTo )
1623 {
1624 RECT rcFrom32, rcTo32;
1625 rcFrom32.left = lprcFrom->left;
1626 rcFrom32.top = lprcFrom->top;
1627 rcFrom32.right = lprcFrom->right;
1628 rcFrom32.bottom = lprcFrom->bottom;
1629 rcTo32.left = lprcTo->left;
1630 rcTo32.top = lprcTo->top;
1631 rcTo32.right = lprcTo->right;
1632 rcTo32.bottom = lprcTo->bottom;
1633 return DrawAnimatedRects( WIN_Handle32(hwnd), idAni, &rcFrom32, &rcTo32 );
1634 }
1635
1636
1637 /***********************************************************************
1638 * GetInternalWindowPos (USER.460)
1639 */
1640 UINT16 WINAPI GetInternalWindowPos16( HWND16 hwnd, LPRECT16 rectWnd, LPPOINT16 ptIcon )
1641 {
1642 WINDOWPLACEMENT16 wndpl;
1643
1644 if (!GetWindowPlacement16( hwnd, &wndpl )) return 0;
1645 if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
1646 if (ptIcon) *ptIcon = wndpl.ptMinPosition;
1647 return wndpl.showCmd;
1648 }
1649
1650
1651 /**************************************************************************
1652 * SetInternalWindowPos (USER.461)
1653 */
1654 void WINAPI SetInternalWindowPos16( HWND16 hwnd, UINT16 showCmd, LPRECT16 rect, LPPOINT16 pt )
1655 {
1656 RECT rc32;
1657 POINT pt32;
1658
1659 if (rect)
1660 {
1661 rc32.left = rect->left;
1662 rc32.top = rect->top;
1663 rc32.right = rect->right;
1664 rc32.bottom = rect->bottom;
1665 }
1666 if (pt)
1667 {
1668 pt32.x = pt->x;
1669 pt32.y = pt->y;
1670 }
1671 SetInternalWindowPos( WIN_Handle32(hwnd), showCmd,
1672 rect ? &rc32 : NULL, pt ? &pt32 : NULL );
1673 }
1674
1675
1676 /**************************************************************************
1677 * CalcChildScroll (USER.462)
1678 */
1679 void WINAPI CalcChildScroll16( HWND16 hwnd, WORD scroll )
1680 {
1681 CalcChildScroll( WIN_Handle32(hwnd), scroll );
1682 }
1683
1684
1685 /**************************************************************************
1686 * ScrollChildren (USER.463)
1687 */
1688 void WINAPI ScrollChildren16(HWND16 hwnd, UINT16 uMsg, WPARAM16 wParam, LPARAM lParam)
1689 {
1690 ScrollChildren( WIN_Handle32(hwnd), uMsg, wParam, lParam );
1691 }
1692
1693
1694 /**************************************************************************
1695 * DragDetect (USER.465)
1696 */
1697 BOOL16 WINAPI DragDetect16( HWND16 hwnd, POINT16 pt )
1698 {
1699 POINT pt32;
1700
1701 pt32.x = pt.x;
1702 pt32.y = pt.y;
1703 return DragDetect( WIN_Handle32(hwnd), pt32 );
1704 }
1705
1706
1707 /**************************************************************************
1708 * SetScrollInfo (USER.475)
1709 */
1710 INT16 WINAPI SetScrollInfo16( HWND16 hwnd, INT16 nBar, const SCROLLINFO *info, BOOL16 redraw )
1711 {
1712 return SetScrollInfo( WIN_Handle32(hwnd), nBar, info, redraw );
1713 }
1714
1715
1716 /**************************************************************************
1717 * GetScrollInfo (USER.476)
1718 */
1719 BOOL16 WINAPI GetScrollInfo16( HWND16 hwnd, INT16 nBar, LPSCROLLINFO info )
1720 {
1721 return GetScrollInfo( WIN_Handle32(hwnd), nBar, info );
1722 }
1723
1724
1725 /**************************************************************************
1726 * EnableScrollBar (USER.482)
1727 */
1728 BOOL16 WINAPI EnableScrollBar16( HWND16 hwnd, INT16 nBar, UINT16 flags )
1729 {
1730 return EnableScrollBar( WIN_Handle32(hwnd), nBar, flags );
1731 }
1732
1733
1734 /**************************************************************************
1735 * GetShellWindow (USER.600)
1736 */
1737 HWND16 WINAPI GetShellWindow16(void)
1738 {
1739 return HWND_16( GetShellWindow() );
1740 }
1741
1742
1743 /**************************************************************************
1744 * GetForegroundWindow (USER.608)
1745 */
1746 HWND16 WINAPI GetForegroundWindow16(void)
1747 {
1748 return HWND_16( GetForegroundWindow() );
1749 }
1750
1751
1752 /**************************************************************************
1753 * SetForegroundWindow (USER.609)
1754 */
1755 BOOL16 WINAPI SetForegroundWindow16( HWND16 hwnd )
1756 {
1757 return SetForegroundWindow( WIN_Handle32(hwnd) );
1758 }
1759
1760
1761 /**************************************************************************
1762 * DrawCaptionTemp (USER.657)
1763 */
1764 BOOL16 WINAPI DrawCaptionTemp16( HWND16 hwnd, HDC16 hdc, const RECT16 *rect,
1765 HFONT16 hFont, HICON16 hIcon, LPCSTR str, UINT16 uFlags )
1766 {
1767 RECT rect32;
1768
1769 if (rect)
1770 {
1771 rect32.left = rect->left;
1772 rect32.top = rect->top;
1773 rect32.right = rect->right;
1774 rect32.bottom = rect->bottom;
1775 }
1776 return DrawCaptionTempA( WIN_Handle32(hwnd), HDC_32(hdc),
1777 rect ? &rect32 : NULL, HFONT_32(hFont),
1778 HICON_32(hIcon), str, uFlags & 0x1f );
1779 }
1780
1781
1782 /**************************************************************************
1783 * DrawCaption (USER.660)
1784 */
1785 BOOL16 WINAPI DrawCaption16( HWND16 hwnd, HDC16 hdc, const RECT16 *rect, UINT16 flags )
1786 {
1787 RECT rect32;
1788
1789 if (rect)
1790 {
1791 rect32.left = rect->left;
1792 rect32.top = rect->top;
1793 rect32.right = rect->right;
1794 rect32.bottom = rect->bottom;
1795 }
1796 return DrawCaption(WIN_Handle32(hwnd), HDC_32(hdc), rect ? &rect32 : NULL, flags);
1797 }
1798
1799
1800 /**************************************************************************
1801 * GetMenuItemRect (USER.665)
1802 */
1803 BOOL16 WINAPI GetMenuItemRect16( HWND16 hwnd, HMENU16 hMenu, UINT16 uItem,
1804 LPRECT16 rect)
1805 {
1806 RECT r32;
1807 BOOL res;
1808 if (!rect) return FALSE;
1809 res = GetMenuItemRect( WIN_Handle32(hwnd), HMENU_32(hMenu), uItem, &r32 );
1810 rect->left = r32.left;
1811 rect->top = r32.top;
1812 rect->right = r32.right;
1813 rect->bottom = r32.bottom;
1814 return res;
1815 }
1816
1817
1818 /**************************************************************************
1819 * SetWindowRgn (USER.668)
1820 */
1821 INT16 WINAPI SetWindowRgn16( HWND16 hwnd, HRGN16 hrgn, BOOL16 redraw )
1822 {
1823 return SetWindowRgn( WIN_Handle32(hwnd), HRGN_32(hrgn), redraw );
1824 }
1825
1826
1827 /**************************************************************************
1828 * MessageBoxIndirect (USER.827)
1829 */
1830 INT16 WINAPI MessageBoxIndirect16( LPMSGBOXPARAMS16 msgbox )
1831 {
1832 MSGBOXPARAMSA msgbox32;
1833
1834 msgbox32.cbSize = msgbox->cbSize;
1835 msgbox32.hwndOwner = WIN_Handle32( msgbox->hwndOwner );
1836 msgbox32.hInstance = HINSTANCE_32(msgbox->hInstance);
1837 msgbox32.lpszText = MapSL(msgbox->lpszText);
1838 msgbox32.lpszCaption = MapSL(msgbox->lpszCaption);
1839 msgbox32.dwStyle = msgbox->dwStyle;
1840 msgbox32.lpszIcon = MapSL(msgbox->lpszIcon);
1841 msgbox32.dwContextHelpId = msgbox->dwContextHelpId;
1842 msgbox32.lpfnMsgBoxCallback = msgbox->lpfnMsgBoxCallback;
1843 msgbox32.dwLanguageId = msgbox->dwLanguageId;
1844 return MessageBoxIndirectA( &msgbox32 );
1845 }
1846
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.