source: trunk/src/user32/new/window.cpp@ 321

Last change on this file since 321 was 321, checked in by sandervl, 26 years ago

* empty log message *
File size: 26.2 KB
Line 
1/* $Id: window.cpp,v 1.4 1999-07-17 11:52:23 sandervl Exp $ */
2/*
3 * Win32 window apis for OS/2
4 *
5 * Copyright 1999 Sander van Leeuwen
6 *
7 * Parts based on Wine Windows code (windows\win.c)
8 *
9 * Copyright 1993, 1994 Alexandre Julliard
10 *
11 * Project Odin Software License can be found in LICENSE.TXT
12 *
13 *
14 * TODO: Decide what to do about commands for OS/2 windows (non-Win32 apps)
15 *
16 */
17
18#include <os2win.h>
19#include <misc.h>
20#include <win32wnd.h>
21
22//******************************************************************************
23//******************************************************************************
24HWND WIN32API CreateWindowExA(DWORD exStyle, LPCSTR className,
25 LPCSTR windowName, DWORD style, INT x,
26 INT y, INT width, INT height,
27 HWND parent, HMENU menu,
28 HINSTANCE instance, LPVOID data )
29{
30 Win32Window *window;
31 ATOM classAtom;
32 CREATESTRUCTA cs;
33
34 if(exStyle & WS_EX_MDICHILD)
35 return CreateMDIWindowA(className, windowName, style, x, y, width, height, parent, instance, (LPARAM)data);
36
37 /* Find the class atom */
38 if (!(classAtom = GlobalFindAtomA(className)))
39 {
40 dprintf(("CreateWindowEx32A: bad class name "));
41 if (!HIWORD(className)) {
42 dprintf(("CreateWindowEx32A: bad class name %04x\n", LOWORD(className)));
43 }
44 else dprintf(("CreateWindowEx32A: bad class name '%s'\n", className ));
45 SetLastError(ERROR_INVALID_PARAMETER);
46 return 0;
47 }
48
49 /* Create the window */
50 cs.lpCreateParams = data;
51 cs.hInstance = instance;
52 cs.hMenu = menu;
53 cs.hwndParent = parent;
54 cs.x = x;
55 cs.y = y;
56 cs.cx = width;
57 cs.cy = height;
58 cs.style = style;
59 cs.lpszName = windowName;
60 cs.lpszClass = className;
61 cs.dwExStyle = exStyle;
62 window = new Win32Window( &cs, classAtom, FALSE );
63 if(window == NULL)
64 {
65 dprintf(("Win32Window creation failed!!"));
66 return 0;
67 }
68 if(GetLastError() != 0)
69 {
70 dprintf(("Win32Window error found!!"));
71 delete window;
72 return 0;
73 }
74 return window->getWindowHandle();
75}
76//******************************************************************************
77//******************************************************************************
78HWND WIN32API CreateMDIWindowA(LPCSTR arg1, LPCSTR arg2, DWORD arg3,
79 int arg4, int arg5, int arg6, int arg7,
80 HWND arg8, HINSTANCE arg9, LPARAM arg10)
81{
82 HWND hwnd;
83
84 dprintf(("USER32: CreateMDIWindowA\n"));
85
86 hwnd = O32_CreateMDIWindow((LPSTR)arg1, (LPSTR)arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
87
88 dprintf(("USER32: CreateMDIWindowA returned %X\n", hwnd));
89 return hwnd;
90}
91//******************************************************************************
92//******************************************************************************
93HWND WIN32API CreateMDIWindowW(LPCWSTR arg1, LPCWSTR arg2, DWORD arg3, int arg4,
94 int arg5, int arg6, int arg7, HWND arg8, HINSTANCE arg9,
95 LPARAM arg10)
96{
97 HWND hwnd;
98 char *astring1 = NULL, *astring2 = NULL;
99
100 if((int)arg1 >> 16 != 0) {
101 astring1 = UnicodeToAsciiString((LPWSTR)arg1);
102 }
103 else astring1 = (char *)arg2;
104
105 astring2 = UnicodeToAsciiString((LPWSTR)arg2);
106
107 hwnd = O32_CreateMDIWindow(astring1, astring2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
108
109 if(astring1) FreeAsciiString(astring1);
110 FreeAsciiString(astring2);
111 dprintf(("USER32: CreateMDIWindowW hwnd = %X\n", hwnd));
112 return(hwnd);
113}
114//******************************************************************************
115//******************************************************************************
116HWND WIN32API CreateWindowExW(DWORD arg1,
117 LPCWSTR arg2,
118 LPCWSTR arg3,
119 DWORD dwStyle,
120 int arg5,
121 int arg6,
122 int arg7,
123 int arg8,
124 HWND arg9,
125 HMENU arg10,
126 HINSTANCE arg11,
127 PVOID arg12)
128{
129 HWND hwnd;
130 char *astring1 = NULL,
131 *astring2 = NULL;
132
133 /* @@@PH 98/06/21 changed to call OS2CreateWindowExA */
134 if(HIWORD(arg2) != 0)
135 astring1 = UnicodeToAsciiString((LPWSTR)arg2);
136 else
137 astring1 = (char *)arg2;
138
139 astring2 = UnicodeToAsciiString((LPWSTR)arg3);
140
141#ifdef DEBUG
142 WriteLog("USER32: CreateWindowExW: dwExStyle = %X\n", arg1);
143 if((int)arg2 >> 16 != 0)
144 WriteLog("USER32: CreateWindow: classname = %s\n", astring1);
145 else WriteLog("USER32: CreateWindow: classname = %X\n", arg2);
146 WriteLog("USER32: CreateWindow: windowname= %s\n", astring2);
147 WriteLog("USER32: CreateWindow: dwStyle = %X\n", dwStyle);
148 WriteLog("USER32: CreateWindow: x = %d\n", arg5);
149 WriteLog("USER32: CreateWindow: y = %d\n", arg6);
150 WriteLog("USER32: CreateWindow: nWidth = %d\n", arg7);
151 WriteLog("USER32: CreateWindow: nHeight = %d\n", arg8);
152 WriteLog("USER32: CreateWindow: parent = %X\n", arg9);
153 WriteLog("USER32: CreateWindow: hwmenu = %X\n", arg10);
154 WriteLog("USER32: CreateWindow: hinstance = %X\n", arg11);
155 WriteLog("USER32: CreateWindow: param = %X\n", arg12);
156 #endif
157
158 hwnd = CreateWindowExA(arg1,
159 astring1,
160 astring2,
161 dwStyle,
162 arg5,
163 arg6,
164 arg7,
165 arg8,
166 arg9,
167 arg10,
168 arg11,
169 arg12);
170
171 if(HIWORD(arg1) != 0)
172 FreeAsciiString(astring1);
173
174 FreeAsciiString(astring2);
175
176#ifdef DEBUG
177 WriteLog("USER32: ************CreateWindowExW hwnd = %X (%X)\n", hwnd, GetLastError());
178#endif
179 return(hwnd);
180}
181//******************************************************************************
182//******************************************************************************
183BOOL WIN32API DestroyWindow(HWND hwnd)
184{
185 Win32Window *window;
186
187 window = Win32Window::GetWindowFromHandle(hwnd);
188 if(!window) {
189 dprintf(("DestroyWindow, window %x not found", hwnd));
190 return 0;
191 }
192 dprintf(("DestroyWindow %x", hwnd));
193 return window->DestroyWindow();
194}
195//******************************************************************************
196//******************************************************************************
197HWND WIN32API SetActiveWindow( HWND hwnd)
198{
199 Win32Window *window;
200
201 window = Win32Window::GetWindowFromHandle(hwnd);
202 if(!window) {
203 dprintf(("SetActiveWindow, window %x not found", hwnd));
204 return 0;
205 }
206 dprintf(("SetActiveWindow %x", hwnd));
207 return window->SetActiveWindow();
208}
209//******************************************************************************
210//******************************************************************************
211HWND WIN32API GetParent( HWND hwnd)
212{
213 Win32Window *window;
214
215 window = Win32Window::GetWindowFromHandle(hwnd);
216 if(!window) {
217 dprintf(("GetParent, window %x not found", hwnd));
218 return 0;
219 }
220 dprintf(("GetParent %x", hwnd));
221 return window->GetParent();
222}
223//******************************************************************************
224//******************************************************************************
225HWND WIN32API SetParent( HWND hwndChild, HWND hwndNewParent)
226{
227 Win32Window *window;
228
229 window = Win32Window::GetWindowFromHandle(hwndChild);
230 if(!window) {
231 dprintf(("SetParent, window %x not found", hwndChild));
232 return 0;
233 }
234 dprintf(("SetParent %x %x", hwndChild, hwndNewParent));
235 return window->SetParent(hwndNewParent);
236}
237//******************************************************************************
238//******************************************************************************
239BOOL WIN32API IsChild( HWND hwndParent, HWND hwnd)
240{
241 Win32Window *window;
242
243 window = Win32Window::GetWindowFromHandle(hwnd);
244 if(!window) {
245 dprintf(("IsChild, window %x not found", hwnd));
246 return 0;
247 }
248 dprintf(("IsChild %x %x", hwndParent, hwnd));
249 return window->IsChild(hwndParent);
250}
251//******************************************************************************
252//******************************************************************************
253HWND WIN32API GetTopWindow( HWND hwnd)
254{
255 Win32Window *window;
256
257 window = Win32Window::GetWindowFromHandle(hwnd);
258 if(!window) {
259 dprintf(("GetTopWindow, window %x not found", hwnd));
260 return 0;
261 }
262 dprintf(("GetTopWindow %x", hwnd));
263 return window->GetTopWindow();
264}
265//******************************************************************************
266//******************************************************************************
267BOOL WIN32API UpdateWindow(HWND hwnd)
268{
269 Win32Window *window;
270
271 window = Win32Window::GetWindowFromHandle(hwnd);
272 if(!window) {
273 dprintf(("UpdateWindow, window %x not found", hwnd));
274 return 0;
275 }
276 dprintf(("UpdateWindow %x", hwnd));
277 return window->UpdateWindow();
278}
279//******************************************************************************
280//******************************************************************************
281BOOL WIN32API IsIconic( HWND hwnd)
282{
283 Win32Window *window;
284
285 window = Win32Window::GetWindowFromHandle(hwnd);
286 if(!window) {
287 dprintf(("IsIconic, window %x not found", hwnd));
288 return 0;
289 }
290 dprintf(("IsIconic %x", hwnd));
291 return window->IsIconic();
292}
293//******************************************************************************
294//******************************************************************************
295HWND WIN32API GetWindow(HWND hwnd, UINT uCmd)
296{
297 Win32Window *window;
298
299 window = Win32Window::GetWindowFromHandle(hwnd);
300 if(!window) {
301 dprintf(("GetWindow, window %x not found", hwnd));
302 return 0;
303 }
304 dprintf(("GetWindow %x %d", hwnd, uCmd));
305 return window->GetWindow(uCmd);
306}
307//******************************************************************************
308//******************************************************************************
309HDC WIN32API GetWindowDC(HWND arg1)
310{
311#ifdef DEBUG
312 WriteLog("USER32: GetWindowDC\n");
313#endif
314 return O32_GetWindowDC(arg1);
315}
316//******************************************************************************
317//******************************************************************************
318BOOL WIN32API EnableWindow( HWND hwnd, BOOL fEnable)
319{
320 Win32Window *window;
321
322 window = Win32Window::GetWindowFromHandle(hwnd);
323 if(!window) {
324 dprintf(("EnableWindow, window %x not found", hwnd));
325 return 0;
326 }
327 dprintf(("EnableWindow %x %d", hwnd, fEnable));
328 return window->EnableWindow(fEnable);
329}
330//******************************************************************************
331//******************************************************************************
332BOOL WIN32API BringWindowToTop(HWND hwnd)
333{
334 Win32Window *window;
335
336 window = Win32Window::GetWindowFromHandle(hwnd);
337 if(!window) {
338 dprintf(("BringWindowToTop, window %x not found", hwnd));
339 return 0;
340 }
341 dprintf(("BringWindowToTop %x", hwnd));
342 return window->BringWindowToTop();
343}
344//******************************************************************************
345//******************************************************************************
346HWND WIN32API GetActiveWindow()
347{
348 return Win32Window::GetActiveWindow();
349}
350//******************************************************************************
351//******************************************************************************
352BOOL WIN32API ShowWindow(HWND hwnd, int nCmdShow)
353{
354 Win32Window *window;
355
356 window = Win32Window::GetWindowFromHandle(hwnd);
357 if(!window) {
358 dprintf(("ShowWindow, window %x not found", hwnd));
359 return 0;
360 }
361 dprintf(("ShowWindow %x", hwnd));
362 return window->ShowWindow(nCmdShow);
363}
364//******************************************************************************
365//******************************************************************************
366BOOL WIN32API SetWindowPos(HWND hwnd, HWND hwndInsertAfter, int x, int y, int cx, int cy, UINT fuFlags)
367{
368 Win32Window *window;
369
370 window = Win32Window::GetWindowFromHandle(hwnd);
371 if(!window) {
372 dprintf(("SetWindowPos, window %x not found", hwnd));
373 return 0;
374 }
375 dprintf(("SetWindowPos %x %x x=%d y=%d cx=%d cy=%d %x", hwnd, hwndInsertAfter, x, y, cx, cy, fuFlags));
376 return window->SetWindowPos(hwndInsertAfter, x, y, cx, cy, fuFlags);
377}
378//******************************************************************************
379//******************************************************************************
380BOOL WIN32API IsWindow( HWND hwnd)
381{
382 Win32Window *window;
383
384 window = Win32Window::GetWindowFromHandle(hwnd);
385 if(!window) {
386 dprintf(("IsWindow, window %x not found", hwnd));
387 return FALSE;
388 }
389 dprintf(("IsWindow %x", hwnd));
390 return window->IsWindow();
391}
392//******************************************************************************
393//******************************************************************************
394BOOL WIN32API IsWindowEnabled( HWND hwnd)
395{
396 Win32Window *window;
397
398 window = Win32Window::GetWindowFromHandle(hwnd);
399 if(!window) {
400 dprintf(("IsWindowEnabled, window %x not found", hwnd));
401 return 0;
402 }
403 dprintf(("IsWindowEnabled %x", hwnd));
404 return window->IsWindowEnabled();
405}
406//******************************************************************************
407//******************************************************************************
408BOOL WIN32API IsWindowVisible( HWND hwnd)
409{
410 Win32Window *window;
411
412 window = Win32Window::GetWindowFromHandle(hwnd);
413 if(!window) {
414 dprintf(("IsWindowVisible, window %x not found", hwnd));
415 return 0;
416 }
417 dprintf(("IsWindowVisible %x", hwnd));
418 return window->IsWindowVisible();
419}
420/***********************************************************************
421 * GetInternalWindowPos (USER32.245)
422 */
423UINT WIN32API GetInternalWindowPos(HWND hwnd,
424 LPRECT rectWnd,
425 LPPOINT ptIcon )
426{
427 WINDOWPLACEMENT wndpl;
428
429 dprintf(("USER32: GetInternalWindowPos(%08xh,%08xh,%08xh)\n",
430 hwnd,
431 rectWnd,
432 ptIcon));
433
434 if (O32_GetWindowPlacement( hwnd, &wndpl ))
435 {
436 if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
437 if (ptIcon) *ptIcon = wndpl.ptMinPosition;
438 return wndpl.showCmd;
439 }
440 return 0;
441}
442//******************************************************************************
443//******************************************************************************
444BOOL WIN32API IsZoomed( HWND arg1)
445{
446#ifdef DEBUG
447 WriteLog("USER32: IsZoomed\n");
448#endif
449 return O32_IsZoomed(arg1);
450}
451//******************************************************************************
452//******************************************************************************
453BOOL WIN32API LockWindowUpdate( HWND arg1)
454{
455#ifdef DEBUG
456 WriteLog("USER32: LockWindowUpdate\n");
457#endif
458 return O32_LockWindowUpdate(arg1);
459}
460//******************************************************************************
461//******************************************************************************
462BOOL WIN32API RedrawWindow( HWND arg1, const RECT * arg2, HRGN arg3, UINT arg4)
463{
464 BOOL rc;
465
466 rc = O32_RedrawWindow(arg1, arg2, arg3, arg4);
467#ifdef DEBUG
468 WriteLog("USER32: RedrawWindow %X , %X, %X, %X returned %d\n", arg1, arg2, arg3, arg4, rc);
469#endif
470 InvalidateRect(arg1, arg2, TRUE);
471 UpdateWindow(arg1);
472 SendMessageA(arg1, WM_PAINT, 0, 0);
473 return(rc);
474}
475//******************************************************************************
476//******************************************************************************
477BOOL WIN32API GetWindowRect( HWND arg1, PRECT arg2)
478{
479 BOOL rc;
480
481 rc = O32_GetWindowRect(arg1, arg2);
482 dprintf(("USER32: GetWindowRect %X returned %d\n", arg1, rc));
483 return(rc);
484}
485//******************************************************************************
486//******************************************************************************
487BOOL WIN32API SetWindowTextA(HWND arg1, LPCSTR arg2)
488{
489#ifdef DEBUG
490 WriteLog("USER32: SetWindowText %s\n", arg2);
491#endif
492 return O32_SetWindowText(arg1, arg2);
493}
494//******************************************************************************
495//******************************************************************************
496BOOL WIN32API SetWindowTextW( HWND arg1, LPCWSTR arg2)
497{
498 char *astring = UnicodeToAsciiString((LPWSTR)arg2);
499 BOOL rc;
500
501 rc = SetWindowTextA(arg1, (LPCSTR)astring);
502 dprintf(("USER32: SetWindowTextW %X %s returned %d\n", arg1, astring, rc));
503 FreeAsciiString(astring);
504 return(rc);
505}
506//******************************************************************************
507//******************************************************************************
508BOOL WIN32API SetForegroundWindow(HWND arg1)
509{
510#ifdef DEBUG
511 WriteLog("USER32: SetForegroundWindow\n");
512#endif
513 return O32_SetForegroundWindow(arg1);
514}
515//******************************************************************************
516//******************************************************************************
517BOOL WIN32API GetClientRect( HWND arg1, PRECT arg2)
518{
519#ifdef DEBUG
520 WriteLog("USER32: GetClientRect of %X\n", arg1);
521#endif
522
523 return O32_GetClientRect(arg1, arg2);
524}
525//******************************************************************************
526//******************************************************************************
527HWND WIN32API FindWindowA(LPCSTR arg1, LPCSTR arg2)
528{
529#ifdef DEBUG
530 WriteLog("USER32: FindWindow\n");
531#endif
532 return O32_FindWindow(arg1, arg2);
533}
534//******************************************************************************
535//******************************************************************************
536HWND WIN32API FindWindowExA(HWND arg1, HWND arg2, LPCSTR arg3, LPCSTR arg4)
537{
538#ifdef DEBUG
539 WriteLog("USER32: FindWindowExA, not completely implemented\n");
540#endif
541 return O32_FindWindow(arg3, arg4);
542}
543//******************************************************************************
544//******************************************************************************
545BOOL WIN32API FlashWindow( HWND arg1, BOOL arg2)
546{
547#ifdef DEBUG
548 WriteLog("USER32: FlashWindow\n");
549#endif
550 return O32_FlashWindow(arg1, arg2);
551}
552//******************************************************************************
553//******************************************************************************
554BOOL WIN32API MoveWindow(HWND arg1, int arg2, int arg3, int arg4, int arg5, BOOL arg6)
555{
556 BOOL rc;
557
558 rc = O32_MoveWindow(arg1, arg2, arg3, arg4, arg5, arg6);
559 dprintf(("USER32: MoveWindow %X to (%d,%d) size (%d,%d), repaint = %d returned %d\n", arg1, arg2, arg3, arg4, arg5, arg6, rc));
560 return(rc);
561}
562//******************************************************************************
563//******************************************************************************
564BOOL WIN32API AdjustWindowRect( PRECT arg1, DWORD arg2, BOOL arg3)
565{
566#ifdef DEBUG
567 WriteLog("USER32: AdjustWindowRect\n");
568#endif
569 return O32_AdjustWindowRect(arg1, arg2, arg3);
570}
571//******************************************************************************
572//******************************************************************************
573BOOL WIN32API AdjustWindowRectEx( PRECT arg1, DWORD arg2, BOOL arg3, DWORD arg4)
574{
575#ifdef DEBUG
576 WriteLog("USER32: AdjustWindowRectEx\n");
577#endif
578 return O32_AdjustWindowRectEx(arg1, arg2, arg3, arg4);
579}
580//******************************************************************************
581//******************************************************************************
582BOOL WIN32API ClientToScreen( HWND arg1, PPOINT arg2)
583{
584#ifdef DEBUG
585//// WriteLog("USER32: ClientToScreen\n");
586#endif
587 return O32_ClientToScreen(arg1, arg2);
588}
589//******************************************************************************
590//******************************************************************************
591HDWP WIN32API BeginDeferWindowPos( int arg1)
592{
593#ifdef DEBUG
594 WriteLog("USER32: BeginDeferWindowPos\n");
595#endif
596 return O32_BeginDeferWindowPos(arg1);
597}
598//******************************************************************************
599//******************************************************************************
600HDWP WIN32API DeferWindowPos( HDWP arg1, HWND arg2, HWND arg3, int arg4, int arg5, int arg6, int arg7, UINT arg8)
601{
602#ifdef DEBUG
603 WriteLog("USER32: DeferWindowPos\n");
604#endif
605 return O32_DeferWindowPos(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
606}
607//******************************************************************************
608//******************************************************************************
609HWND WIN32API ChildWindowFromPoint( HWND arg1, POINT arg2)
610{
611#ifdef DEBUG
612 WriteLog("USER32: ChildWindowFromPoint\n");
613#endif
614 return O32_ChildWindowFromPoint(arg1, arg2);
615}
616//******************************************************************************
617//******************************************************************************
618HWND WIN32API ChildWindowFromPointEx(HWND arg1, POINT arg2, UINT uFlags)
619{
620#ifdef DEBUG
621 WriteLog("USER32: ChildWindowFromPointEx, not completely supported!\n");
622#endif
623 return O32_ChildWindowFromPoint(arg1, arg2);
624}
625//******************************************************************************
626//******************************************************************************
627BOOL WIN32API CloseWindow( HWND arg1)
628{
629#ifdef DEBUG
630 WriteLog("USER32: CloseWindow\n");
631#endif
632 return O32_CloseWindow(arg1);
633}
634//******************************************************************************
635//******************************************************************************
636HWND WIN32API WindowFromDC( HDC arg1)
637{
638#ifdef DEBUG
639 WriteLog("USER32: WindowFromDC\n");
640#endif
641 return O32_WindowFromDC(arg1);
642}
643//******************************************************************************
644//******************************************************************************
645HWND WIN32API WindowFromPoint( POINT arg1)
646{
647#ifdef DEBUG
648 WriteLog("USER32: WindowFromPoint\n");
649#endif
650 return O32_WindowFromPoint(arg1);
651}
652//******************************************************************************
653//******************************************************************************
654BOOL WIN32API IsWindowUnicode(HWND hwnd)
655{
656#ifdef DEBUG
657 WriteLog("USER32: IsWindowUnicode, not implemented\n");
658#endif
659 return(FALSE);
660}
661/*****************************************************************************
662 * Name : WORD WIN32API CascadeWindows
663 * Purpose : The CascadeWindows function cascades the specified windows or
664 * the child windows of the specified parent window.
665 * Parameters: HWND hwndParent handle of parent window
666 * UINT wHow types of windows not to arrange
667 * CONST RECT * lpRect rectangle to arrange windows in
668 * UINT cKids number of windows to arrange
669 * const HWND FAR * lpKids array of window handles
670 * Variables :
671 * Result : If the function succeeds, the return value is the number of windows arranged.
672 * If the function fails, the return value is zero.
673 * Remark :
674 * Status : UNTESTED STUB
675 *
676 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
677 *****************************************************************************/
678
679WORD WIN32API CascadeWindows(HWND hwndParent,
680 UINT wHow,
681 CONST LPRECT lpRect,
682 UINT cKids,
683 const HWND *lpKids)
684{
685 dprintf(("USER32:CascadeWindows(%08xh,%u,%08xh,%u,%08x) not implemented.\n",
686 hwndParent,
687 wHow,
688 lpRect,
689 cKids,
690 lpKids));
691
692 return (0);
693}
694/*****************************************************************************
695 * Name : HWND WIN32API FindWindowExW
696 * Purpose : The FindWindowEx function retrieves the handle of a window whose
697 * class name and window name match the specified strings. The
698 * function searches child windows, beginning with the one following
699 * the given child window.
700 * Parameters: HWND hwndParent handle of parent window
701 * HWND hwndChildAfter handle of a child window
702 * LPCTSTR lpszClass address of class name
703 * LPCTSTR lpszWindow address of window name
704 * Variables :
705 * Result : If the function succeeds, the return value is the handle of the
706 * window that has the specified class and window names.
707 * If the function fails, the return value is NULL. To get extended
708 * error information, call GetLastError.
709 * Remark :
710 * Status : UNTESTED STUB
711 *
712 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
713 *****************************************************************************/
714
715HWND WIN32API FindWindowExW(HWND hwndParent,
716 HWND hwndChildAfter,
717 LPCWSTR lpszClass,
718 LPCWSTR lpszWindow)
719{
720 dprintf(("USER32:FindWindowExW (%08xh,%08xh,%s,%s) not implemented.\n",
721 hwndParent,
722 hwndChildAfter,
723 lpszClass,
724 lpszWindow));
725
726 return (NULL);
727}
728/*****************************************************************************
729 * Name : BOOL WIN32API SwitchToThisWindow
730 * Purpose : Unknown
731 * Parameters: Unknown
732 * Variables :
733 * Result :
734 * Remark :
735 * Status : UNTESTED UNKNOWN STUB
736 *
737 * Author : Patrick Haller [Wed, 1998/06/16 11:55]
738 *****************************************************************************/
739
740BOOL WIN32API SwitchToThisWindow(HWND hwnd,
741 BOOL x2)
742{
743 dprintf(("USER32: SwitchToThisWindow(%08xh,%08xh) not implemented.\n",
744 hwnd,
745 x2));
746
747 return (FALSE); /* default */
748}
749//******************************************************************************
750//******************************************************************************
Note: See TracBrowser for help on using the repository browser.