?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Make sure that all MDI children have the WS_EX_MDICHILD style set.
[wine/dcerpc.git] / windows / mdi.c
blob3547b44f6e6adf932d99ba7a1225f9eb36808b49
1 /* MDI.C
2 *
3 * Copyright 1994, Bob Amstadt
4 * 1995,1996 Alex Korobka
5 *
6 * This file contains routines to support MDI features.
7 *
8 * Notes: Fairly complete implementation. Any volunteers for
9 * "More windows..." stuff?
10 *
11 * Also, Excel and WinWord do _not_ use MDI so if you're trying
12 * to fix them look elsewhere.
13 */
14
15 #include <stdlib.h>
16 #include <string.h>
17 #include <math.h>
18 #include "winuser.h"
19 #include "win.h"
20 #include "heap.h"
21 #include "nonclient.h"
22 #include "mdi.h"
23 #include "user.h"
24 #include "menu.h"
25 #include "resource.h"
26 #include "scroll.h"
27 #include "struct32.h"
28 #include "tweak.h"
29 #include "debugtools.h"
30
31 DEFAULT_DEBUG_CHANNEL(mdi)
32
33 #define MDIF_NEEDUPDATE 0x0001
34
35 static HBITMAP16 hBmpClose = 0;
36 static HBITMAP16 hBmpRestore = 0;
37
38 /* ----------------- declarations ----------------- */
39 static void MDI_UpdateFrameText(WND *, HWND, BOOL, LPCSTR);
40 static BOOL MDI_AugmentFrameMenu(MDICLIENTINFO*, WND *, HWND);
41 static BOOL MDI_RestoreFrameMenu(WND *, HWND);
42
43 static LONG MDI_ChildActivate( WND*, HWND );
44
45 /* -------- Miscellaneous service functions ----------
46 *
47 * MDI_GetChildByID
48 */
49
50 static HWND MDI_GetChildByID(WND* wndPtr, INT id)
51 {
52 for (wndPtr = wndPtr->child; wndPtr; wndPtr = wndPtr->next)
53 if (wndPtr->wIDmenu == id) return wndPtr->hwndSelf;
54 return 0;
55 }
56
57 static void MDI_PostUpdate(HWND hwnd, MDICLIENTINFO* ci, WORD recalc)
58 {
59 if( !(ci->mdiFlags & MDIF_NEEDUPDATE) )
60 {
61 ci->mdiFlags |= MDIF_NEEDUPDATE;
62 PostMessageA( hwnd, WM_MDICALCCHILDSCROLL, 0, 0);
63 }
64 ci->sbRecalc = recalc;
65 }
66
67 /**********************************************************************
68 * MDI_MenuModifyItem
69 */
70 static BOOL MDI_MenuModifyItem(WND* clientWnd, HWND hWndChild )
71 {
72 char buffer[128];
73 MDICLIENTINFO *clientInfo = (MDICLIENTINFO*)clientWnd->wExtra;
74 WND *wndPtr = WIN_FindWndPtr(hWndChild);
75 UINT n = sprintf(buffer, "%d ",
76 wndPtr->wIDmenu - clientInfo->idFirstChild + 1);
77 BOOL bRet = 0;
78
79 if( !clientInfo->hWindowMenu )
80 {
81 bRet = FALSE;
82 goto END;
83 }
84
85 if (wndPtr->text) lstrcpynA(buffer + n, wndPtr->text, sizeof(buffer) - n );
86
87 n = GetMenuState(clientInfo->hWindowMenu,wndPtr->wIDmenu ,MF_BYCOMMAND);
88 bRet = ModifyMenuA(clientInfo->hWindowMenu , wndPtr->wIDmenu,
89 MF_BYCOMMAND | MF_STRING, wndPtr->wIDmenu, buffer );
90 CheckMenuItem(clientInfo->hWindowMenu ,wndPtr->wIDmenu , n & MF_CHECKED);
91 END:
92 WIN_ReleaseWndPtr(wndPtr);
93 return bRet;
94 }
95
96 /**********************************************************************
97 * MDI_MenuDeleteItem
98 */
99 static BOOL MDI_MenuDeleteItem(WND* clientWnd, HWND hWndChild )
100 {
101 char buffer[128];
102 MDICLIENTINFO *clientInfo = (MDICLIENTINFO*)clientWnd->wExtra;
103 WND *wndPtr = WIN_FindWndPtr(hWndChild);
104 UINT index = 0,id,n;
105 BOOL retvalue;
106
107 if( !clientInfo->nActiveChildren ||
108 !clientInfo->hWindowMenu )
109 {
110 retvalue = FALSE;
111 goto END;
112 }
113
114 id = wndPtr->wIDmenu;
115 DeleteMenu(clientInfo->hWindowMenu,id,MF_BYCOMMAND);
116
117 /* walk the rest of MDI children to prevent gaps in the id
118 * sequence and in the menu child list */
119
120 for( index = id+1; index <= clientInfo->nActiveChildren +
121 clientInfo->idFirstChild; index++ )
122 {
123 WND *tmpWnd = WIN_FindWndPtr(MDI_GetChildByID(clientWnd,index));
124 if( !tmpWnd )
125 {
126 TRACE("no window for id=%i\n",index);
127 WIN_ReleaseWndPtr(tmpWnd);
128 continue;
129 }
130
131 /* set correct id */
132 tmpWnd->wIDmenu--;
133
134 n = sprintf(buffer, "%d ",index - clientInfo->idFirstChild);
135 if (tmpWnd->text)
136 lstrcpynA(buffer + n, tmpWnd->text, sizeof(buffer) - n );
137
138 /* change menu */
139 ModifyMenuA(clientInfo->hWindowMenu ,index ,MF_BYCOMMAND | MF_STRING,
140 index - 1 , buffer );
141 WIN_ReleaseWndPtr(tmpWnd);
142 }
143 retvalue = TRUE;
144 END:
145 WIN_ReleaseWndPtr(wndPtr);
146 return retvalue;
147 }
148
149 /**********************************************************************
150 * MDI_GetWindow
151 *
152 * returns "activateable" child different from the current or zero
153 */
154 static HWND MDI_GetWindow(WND *clientWnd, HWND hWnd, BOOL bNext,
155 DWORD dwStyleMask )
156 {
157 MDICLIENTINFO *clientInfo = (MDICLIENTINFO*)clientWnd->wExtra;
158 WND *wndPtr, *pWnd, *pWndLast = NULL;
159
160 dwStyleMask |= WS_DISABLED | WS_VISIBLE;
161 if( !hWnd ) hWnd = clientInfo->hwndActiveChild;
162
163 if( !(wndPtr = WIN_FindWndPtr(hWnd)) ) return 0;
164
165 for ( pWnd = WIN_LockWndPtr(wndPtr->next); ; WIN_UpdateWndPtr(&pWnd,pWnd->next))
166 {
167 if (!pWnd ) WIN_UpdateWndPtr(&pWnd,wndPtr->parent->child);
168
169 if ( pWnd == wndPtr ) break; /* went full circle */
170
171 if (!pWnd->owner && (pWnd->dwStyle & dwStyleMask) == WS_VISIBLE )
172 {
173 pWndLast = pWnd;
174 if ( bNext ) break;
175 }
176 }
177 WIN_ReleaseWndPtr(wndPtr);
178 WIN_ReleaseWndPtr(pWnd);
179 return pWndLast ? pWndLast->hwndSelf : 0;
180 }
181
182 /**********************************************************************
183 * MDI_CalcDefaultChildPos
184 *
185 * It seems that the default height is about 2/3 of the client rect
186 */
187 static void MDI_CalcDefaultChildPos( WND* w, WORD n, LPPOINT lpPos,
188 INT delta)
189 {
190 INT nstagger;
191 RECT rect = w->rectClient;
192 INT spacing = GetSystemMetrics(SM_CYCAPTION) +
193 GetSystemMetrics(SM_CYFRAME) - 1;
194
195 if( rect.bottom - rect.top - delta >= spacing )
196 rect.bottom -= delta;
197
198 nstagger = (rect.bottom - rect.top)/(3 * spacing);
199 lpPos[1].x = (rect.right - rect.left - nstagger * spacing);
200 lpPos[1].y = (rect.bottom - rect.top - nstagger * spacing);
201 lpPos[0].x = lpPos[0].y = spacing * (n%(nstagger+1));
202 }
203
204 /**********************************************************************
205 * MDISetMenu
206 */
207 static LRESULT MDISetMenu( HWND hwnd, HMENU hmenuFrame,
208 HMENU hmenuWindow)
209 {
210 WND *w = WIN_FindWndPtr(hwnd);
211 MDICLIENTINFO *ci;
212 HWND hwndFrame = GetParent(hwnd);
213 HMENU oldFrameMenu = GetMenu(hwndFrame);
214
215 TRACE("%04x %04x %04x\n",
216 hwnd, hmenuFrame, hmenuWindow);
217
218 ci = (MDICLIENTINFO *) w->wExtra;
219
220 if( ci->hwndChildMaximized && hmenuFrame && hmenuFrame!=oldFrameMenu )
221 MDI_RestoreFrameMenu(w->parent, ci->hwndChildMaximized );
222
223 if( hmenuWindow && hmenuWindow!=ci->hWindowMenu )
224 {
225 /* delete menu items from ci->hWindowMenu
226 * and add them to hmenuWindow */
227
228 INT i = GetMenuItemCount(ci->hWindowMenu) - 1;
229 INT pos = GetMenuItemCount(hmenuWindow) + 1;
230
231 AppendMenuA( hmenuWindow, MF_SEPARATOR, 0, NULL);
232
233 if( ci->nActiveChildren )
234 {
235 INT j = i - ci->nActiveChildren + 1;
236 char buffer[100];
237 UINT id,state;
238
239 for( ; i >= j ; i-- )
240 {
241 id = GetMenuItemID(ci->hWindowMenu,i );
242 state = GetMenuState(ci->hWindowMenu,i,MF_BYPOSITION);
243
244 GetMenuStringA(ci->hWindowMenu, i, buffer, 100, MF_BYPOSITION);
245
246 DeleteMenu(ci->hWindowMenu, i , MF_BYPOSITION);
247 InsertMenuA(hmenuWindow, pos, MF_BYPOSITION | MF_STRING,
248 id, buffer);
249 CheckMenuItem(hmenuWindow ,pos , MF_BYPOSITION | (state & MF_CHECKED));
250 }
251 }
252
253 /* remove separator */
254 DeleteMenu(ci->hWindowMenu, i, MF_BYPOSITION);
255
256 ci->hWindowMenu = hmenuWindow;
257 }
258
259 if( hmenuFrame && hmenuFrame!=oldFrameMenu)
260 {
261 SetMenu(hwndFrame, hmenuFrame);
262 if( ci->hwndChildMaximized )
263 MDI_AugmentFrameMenu(ci, w->parent, ci->hwndChildMaximized );
264 WIN_ReleaseWndPtr(w);
265 return oldFrameMenu;
266 }
267 WIN_ReleaseWndPtr(w);
268 return 0;
269 }
270
271 /**********************************************************************
272 * MDIRefreshMenu
273 */
274 static LRESULT MDIRefreshMenu( HWND hwnd, HMENU hmenuFrame,
275 HMENU hmenuWindow)
276 {
277 HWND hwndFrame = GetParent(hwnd);
278 HMENU oldFrameMenu = GetMenu(hwndFrame);
279
280 TRACE("%04x %04x %04x\n",
281 hwnd, hmenuFrame, hmenuWindow);
282
283 FIXME("partially function stub\n");
284
285 return oldFrameMenu;
286 }
287
288
289 /* ------------------ MDI child window functions ---------------------- */
290
291
292 /**********************************************************************
293 * MDICreateChild
294 */
295 static HWND MDICreateChild( WND *w, MDICLIENTINFO *ci, HWND parent,
296 LPMDICREATESTRUCTA cs )
297 {
298 POINT pos[2];
299 DWORD style = cs->style | (WS_CHILD | WS_CLIPSIBLINGS);
300 HWND hwnd, hwndMax = 0;
301 WORD wIDmenu = ci->idFirstChild + ci->nActiveChildren;
302 char lpstrDef[]="junk!";
303
304 TRACE("origin %i,%i - dim %i,%i, style %08x\n",
305 cs->x, cs->y, cs->cx, cs->cy, (unsigned)cs->style);
306 /* calculate placement */
307 MDI_CalcDefaultChildPos(w, ci->nTotalCreated++, pos, 0);
308
309 if (cs->cx == CW_USEDEFAULT || !cs->cx) cs->cx = pos[1].x;
310 if (cs->cy == CW_USEDEFAULT || !cs->cy) cs->cy = pos[1].y;
311
312 if( cs->x == CW_USEDEFAULT )
313 {
314 cs->x = pos[0].x;
315 cs->y = pos[0].y;
316 }
317
318 /* restore current maximized child */
319 if( style & WS_VISIBLE && ci->hwndChildMaximized )
320 {
321 if( style & WS_MAXIMIZE )
322 SendMessageA(w->hwndSelf, WM_SETREDRAW, FALSE, 0L );
323 hwndMax = ci->hwndChildMaximized;
324 ShowWindow( hwndMax, SW_SHOWNOACTIVATE );
325 if( style & WS_MAXIMIZE )
326 SendMessageA(w->hwndSelf, WM_SETREDRAW, TRUE, 0L );
327 }
328
329 /* this menu is needed to set a check mark in MDI_ChildActivate */
330 AppendMenuA(ci->hWindowMenu ,MF_STRING ,wIDmenu, lpstrDef );
331
332 ci->nActiveChildren++;
333
334 /* fix window style */
335 if( !(w->dwStyle & MDIS_ALLCHILDSTYLES) )
336 {
337 style &= (WS_CHILD | WS_CLIPSIBLINGS | WS_MINIMIZE | WS_MAXIMIZE |
338 WS_CLIPCHILDREN | WS_DISABLED | WS_VSCROLL | WS_HSCROLL );
339 style |= (WS_VISIBLE | WS_OVERLAPPEDWINDOW);
340 }
341
342 if( w->flags & WIN_ISWIN32 )
343 {
344 hwnd = CreateWindowA( cs->szClass, cs->szTitle, style,
345 cs->x, cs->y, cs->cx, cs->cy, parent,
346 (HMENU16)wIDmenu, cs->hOwner, cs );
347 }
348 else
349 {
350 MDICREATESTRUCT16 *cs16;
351 LPSTR title, cls;
352
353 cs16 = SEGPTR_NEW(MDICREATESTRUCT16);
354 STRUCT32_MDICREATESTRUCT32Ato16( cs, cs16 );
355 title = SEGPTR_STRDUP( cs->szTitle );
356 cls = SEGPTR_STRDUP( cs->szClass );
357 cs16->szTitle = SEGPTR_GET(title);
358 cs16->szClass = SEGPTR_GET(cls);
359
360 hwnd = CreateWindow16( cs->szClass, cs->szTitle, style,
361 cs16->x, cs16->y, cs16->cx, cs16->cy, parent,
362 (HMENU)wIDmenu, cs16->hOwner,
363 (LPVOID)SEGPTR_GET(cs16) );
364 SEGPTR_FREE( title );
365 SEGPTR_FREE( cls );
366 SEGPTR_FREE( cs16 );
367 }
368
369 /* MDI windows are WS_CHILD so they won't be activated by CreateWindow */
370
371 if (hwnd)
372 {
373 WND* wnd = WIN_FindWndPtr( hwnd );
374
375 /* All MDI child windows have the WS_EX_MDICHILD style */
376 wnd->dwExStyle |= WS_EX_MDICHILD;
377
378 MDI_MenuModifyItem(w ,hwnd);
379 if( wnd->dwStyle & WS_MINIMIZE && ci->hwndActiveChild )
380 ShowWindow( hwnd, SW_SHOWMINNOACTIVE );
381 else
382 {
383 /* WS_VISIBLE is clear if a) the MDI client has
384 * MDIS_ALLCHILDSTYLES style and 2) the flag is cleared in the
385 * MDICreateStruct. If so the created window is not shown nor
386 * activated.
387 */
388 int showflag=wnd->dwStyle & WS_VISIBLE;
389 /* clear visible flag, otherwise SetWindoPos32 ignores
390 * the SWP_SHOWWINDOW command.
391 */
392 wnd->dwStyle &= ~WS_VISIBLE;
393 if(showflag){
394 SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE );
395
396 /* Set maximized state here in case hwnd didn't receive WM_SIZE
397 * during CreateWindow - bad!
398 */
399
400 if((wnd->dwStyle & WS_MAXIMIZE) && !ci->hwndChildMaximized )
401 {
402 ci->hwndChildMaximized = wnd->hwndSelf;
403 MDI_AugmentFrameMenu( ci, w->parent, hwnd );
404 MDI_UpdateFrameText( w->parent, ci->self, MDI_REPAINTFRAME, NULL );
405 }
406 }else
407 /* needed, harmless ? */
408 SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE );
409
410 }
411 WIN_ReleaseWndPtr(wnd);
412 TRACE("created child - %04x\n",hwnd);
413 }
414 else
415 {
416 ci->nActiveChildren--;
417 DeleteMenu(ci->hWindowMenu,wIDmenu,MF_BYCOMMAND);
418 if( IsWindow(hwndMax) )
419 ShowWindow(hwndMax, SW_SHOWMAXIMIZED);
420 }
421
422 return hwnd;
423 }
424
425 /**********************************************************************
426 * MDI_ChildGetMinMaxInfo
427 *
428 * Note: The rule here is that client rect of the maximized MDI child
429 * is equal to the client rect of the MDI client window.
430 */
431 static void MDI_ChildGetMinMaxInfo( WND* clientWnd, HWND hwnd,
432 MINMAXINFO16* lpMinMax )
433 {
434 WND* childWnd = WIN_FindWndPtr(hwnd);
435 RECT rect = clientWnd->rectClient;
436
437 MapWindowPoints( clientWnd->parent->hwndSelf,
438 ((MDICLIENTINFO*)clientWnd->wExtra)->self, (LPPOINT)&rect, 2);
439 AdjustWindowRectEx( &rect, childWnd->dwStyle, 0, childWnd->dwExStyle );
440
441 lpMinMax->ptMaxSize.x = rect.right -= rect.left;
442 lpMinMax->ptMaxSize.y = rect.bottom -= rect.top;
443
444 lpMinMax->ptMaxPosition.x = rect.left;
445 lpMinMax->ptMaxPosition.y = rect.top;
446
447 WIN_ReleaseWndPtr(childWnd);
448
449 TRACE("max rect (%i,%i - %i, %i)\n",
450 rect.left,rect.top,rect.right,rect.bottom);
451
452 }
453
454 /**********************************************************************
455 * MDI_SwitchActiveChild
456 *
457 * Note: SetWindowPos sends WM_CHILDACTIVATE to the child window that is
458 * being activated
459 */
460 static void MDI_SwitchActiveChild( HWND clientHwnd, HWND childHwnd,
461 BOOL bNextWindow )
462 {
463 WND *w = WIN_FindWndPtr(clientHwnd);
464 HWND hwndTo = 0;
465 HWND hwndPrev = 0;
466 MDICLIENTINFO *ci;
467
468 hwndTo = MDI_GetWindow(w, childHwnd, bNextWindow, 0);
469
470 ci = (MDICLIENTINFO *) w->wExtra;
471
472 TRACE("from %04x, to %04x\n",childHwnd,hwndTo);
473
474 if ( !hwndTo ) goto END; /* no window to switch to */
475
476 hwndPrev = ci->hwndActiveChild;
477
478 if ( hwndTo != hwndPrev )
479 {
480 BOOL bOptimize = 0;
481
482 if( ci->hwndChildMaximized )
483 {
484 bOptimize = 1;
485 w->dwStyle &= ~WS_VISIBLE;
486 }
487
488 SetWindowPos( hwndTo, HWND_TOP, 0, 0, 0, 0,
489 SWP_NOMOVE | SWP_NOSIZE );
490
491 if( bNextWindow && hwndPrev )
492 SetWindowPos( hwndPrev, HWND_BOTTOM, 0, 0, 0, 0,
493 SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE );
494 if( bOptimize )
495 ShowWindow( clientHwnd, SW_SHOW );
496 }
497 END:
498 WIN_ReleaseWndPtr(w);
499 }
500
501
502 /**********************************************************************
503 * MDIDestroyChild
504 */
505 static LRESULT MDIDestroyChild( WND *w_parent, MDICLIENTINFO *ci,
506 HWND parent, HWND child,
507 BOOL flagDestroy )
508 {
509 WND *childPtr = WIN_FindWndPtr(child);
510
511 if( childPtr )
512 {
513 if( child == ci->hwndActiveChild )
514 {
515 MDI_SwitchActiveChild(parent, child, TRUE);
516
517 if( child == ci->hwndActiveChild )
518 {
519 ShowWindow( child, SW_HIDE);
520 if( child == ci->hwndChildMaximized )
521 {
522 MDI_RestoreFrameMenu(w_parent->parent, child);
523 ci->hwndChildMaximized = 0;
524 MDI_UpdateFrameText(w_parent->parent,parent,TRUE,NULL);
525 }
526
527 MDI_ChildActivate(w_parent, 0);
528 }
529 }
530 MDI_MenuDeleteItem(w_parent, child);
531
532 WIN_ReleaseWndPtr(childPtr);
533
534 ci->nActiveChildren--;
535
536 TRACE("child destroyed - %04x\n",child);
537
538 if (flagDestroy)
539 {
540 MDI_PostUpdate(GetParent(child), ci, SB_BOTH+1);
541 DestroyWindow(child);
542 }
543 }
544
545 return 0;
546 }
547
548
549 /**********************************************************************
550 * MDI_ChildActivate
551 *
552 * Note: hWndChild is NULL when last child is being destroyed
553 */
554 static LONG MDI_ChildActivate( WND *clientPtr, HWND hWndChild )
555 {
556 MDICLIENTINFO *clientInfo = (MDICLIENTINFO*)clientPtr->wExtra;
557 HWND prevActiveWnd = clientInfo->hwndActiveChild;
558 WND *wndPtr = WIN_FindWndPtr( hWndChild );
559 WND *wndPrev = WIN_FindWndPtr( prevActiveWnd );
560 BOOL isActiveFrameWnd = 0;
561 LONG retvalue;
562
563 if( wndPtr )
564 {
565 if( wndPtr->dwStyle & WS_DISABLED )
566 {
567 retvalue = 0L;
568 goto END;
569 }
570 }
571
572 TRACE("%04x\n", hWndChild);
573
574 if( GetActiveWindow() == clientPtr->parent->hwndSelf )
575 isActiveFrameWnd = TRUE;
576
577 /* deactivate prev. active child */
578 if( wndPrev )
579 {
580 wndPrev->dwStyle |= WS_SYSMENU;
581 SendMessageA( prevActiveWnd, WM_NCACTIVATE, FALSE, 0L );
582 SendMessageA( prevActiveWnd, WM_MDIACTIVATE, (WPARAM)prevActiveWnd,
583 (LPARAM)hWndChild);
584 /* uncheck menu item */
585 if( clientInfo->hWindowMenu )
586 CheckMenuItem( clientInfo->hWindowMenu,
587 wndPrev->wIDmenu, 0);
588 }
589
590 /* set appearance */
591 if( clientInfo->hwndChildMaximized )
592 {
593 if( clientInfo->hwndChildMaximized != hWndChild ) {
594 if( hWndChild ) {
595 clientInfo->hwndActiveChild = hWndChild;
596 ShowWindow( hWndChild, SW_SHOWMAXIMIZED);
597 } else
598 ShowWindow( clientInfo->hwndActiveChild, SW_SHOWNORMAL );
599 }
600 }
601
602 clientInfo->hwndActiveChild = hWndChild;
603
604 /* check if we have any children left */
605 if( !hWndChild )
606 {
607 if( isActiveFrameWnd )
608 SetFocus( clientInfo->self );
609 retvalue = 0;
610 goto END;
611 }
612
613 /* check menu item */
614 if( clientInfo->hWindowMenu )
615 CheckMenuItem( clientInfo->hWindowMenu,
616 wndPtr->wIDmenu, MF_CHECKED);
617
618 /* bring active child to the top */
619 SetWindowPos( hWndChild, 0,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
620
621 if( isActiveFrameWnd )
622 {
623 SendMessageA( hWndChild, WM_NCACTIVATE, TRUE, 0L);
624 if( GetFocus() == clientInfo->self )
625 SendMessageA( clientInfo->self, WM_SETFOCUS,
626 (WPARAM)clientInfo->self, 0L );
627 else
628 SetFocus( clientInfo->self );
629 }
630 SendMessageA( hWndChild, WM_MDIACTIVATE, (WPARAM)prevActiveWnd,
631 (LPARAM)hWndChild );
632 retvalue = 1;
633 END:
634 WIN_ReleaseWndPtr(wndPtr);
635 WIN_ReleaseWndPtr(wndPrev);
636 return retvalue;
637 }
638
639 /* -------------------- MDI client window functions ------------------- */
640
641 /**********************************************************************
642 * CreateMDIMenuBitmap
643 */
644 static HBITMAP16 CreateMDIMenuBitmap(void)
645 {
646 HDC hDCSrc = CreateCompatibleDC(0);
647 HDC hDCDest = CreateCompatibleDC(hDCSrc);
648 HBITMAP16 hbClose = LoadBitmap16(0, MAKEINTRESOURCE16(OBM_CLOSE) );
649 HBITMAP16 hbCopy;
650 HANDLE16 hobjSrc, hobjDest;
651
652 hobjSrc = SelectObject(hDCSrc, hbClose);
653 hbCopy = CreateCompatibleBitmap(hDCSrc,GetSystemMetrics(SM_CXSIZE),GetSystemMetrics(SM_CYSIZE));
654 hobjDest = SelectObject(hDCDest, hbCopy);
655
656 BitBlt(hDCDest, 0, 0, GetSystemMetrics(SM_CXSIZE), GetSystemMetrics(SM_CYSIZE),
657 hDCSrc, GetSystemMetrics(SM_CXSIZE), 0, SRCCOPY);
658
659 SelectObject(hDCSrc, hobjSrc);
660 DeleteObject(hbClose);
661 DeleteDC(hDCSrc);
662
663 hobjSrc = SelectObject( hDCDest, GetStockObject(BLACK_PEN) );
664
665 MoveToEx( hDCDest, GetSystemMetrics(SM_CXSIZE) - 1, 0, NULL );
666 LineTo( hDCDest, GetSystemMetrics(SM_CXSIZE) - 1, GetSystemMetrics(SM_CYSIZE) - 1);
667
668 SelectObject(hDCDest, hobjSrc );
669 SelectObject(hDCDest, hobjDest);
670 DeleteDC(hDCDest);
671
672 return hbCopy;
673 }
674
675 /**********************************************************************
676 * MDICascade
677 */
678 static LONG MDICascade(WND* clientWnd, MDICLIENTINFO *ci)
679 {
680 WND** ppWnd;
681 UINT total;
682
683 if (ci->hwndChildMaximized)
684 SendMessageA( clientWnd->hwndSelf, WM_MDIRESTORE,
685 (WPARAM)ci->hwndChildMaximized, 0);
686
687 if (ci->nActiveChildren == 0) return 0;
688
689 if ((ppWnd = WIN_BuildWinArray(clientWnd, BWA_SKIPHIDDEN | BWA_SKIPOWNED |
690 BWA_SKIPICONIC, &total)))
691 {
692 WND** heapPtr = ppWnd;
693 if( total )
694 {
695 INT delta = 0, n = 0;
696 POINT pos[2];
697 if( total < ci->nActiveChildren )
698 delta = GetSystemMetrics(SM_CYICONSPACING) +
699 GetSystemMetrics(SM_CYICON);
700
701 /* walk the list (backwards) and move windows */
702 while (*ppWnd) ppWnd++;
703 while (ppWnd != heapPtr)
704 {
705 ppWnd--;
706 TRACE("move %04x to (%ld,%ld) size [%ld,%ld]\n",
707 (*ppWnd)->hwndSelf, pos[0].x, pos[0].y, pos[1].x, pos[1].y);
708
709 MDI_CalcDefaultChildPos(clientWnd, n++, pos, delta);
710 SetWindowPos( (*ppWnd)->hwndSelf, 0, pos[0].x, pos[0].y,
711 pos[1].x, pos[1].y,
712 SWP_DRAWFRAME | SWP_NOACTIVATE | SWP_NOZORDER);
713 }
714 }
715 WIN_ReleaseWinArray(heapPtr);
716 }
717
718 if( total < ci->nActiveChildren )
719 ArrangeIconicWindows( clientWnd->hwndSelf );
720 return 0;
721 }
722
723 /**********************************************************************
724 * MDITile
725 */
726 static void MDITile( WND* wndClient, MDICLIENTINFO *ci, WPARAM wParam )
727 {
728 WND** ppWnd;
729 UINT total = 0;
730
731 if (ci->hwndChildMaximized)
732 SendMessageA( wndClient->hwndSelf, WM_MDIRESTORE,
733 (WPARAM)ci->hwndChildMaximized, 0);
734
735 if (ci->nActiveChildren == 0) return;
736
737 ppWnd = WIN_BuildWinArray(wndClient, BWA_SKIPHIDDEN | BWA_SKIPOWNED | BWA_SKIPICONIC |
738 ((wParam & MDITILE_SKIPDISABLED)? BWA_SKIPDISABLED : 0), &total );
739
740 TRACE("%u windows to tile\n", total);
741
742 if( ppWnd )
743 {
744 WND** heapPtr = ppWnd;
745
746 if( total )
747 {
748 RECT rect;
749 int x, y, xsize, ysize;
750 int rows, columns, r, c, i;
751
752 GetClientRect(wndClient->hwndSelf,&rect);
753 rows = (int) sqrt((double)total);
754 columns = total / rows;
755
756 if( wParam & MDITILE_HORIZONTAL ) /* version >= 3.1 */
757 {
758 i = rows;
759 rows = columns; /* exchange r and c */
760 columns = i;
761 }
762
763 if( total != ci->nActiveChildren)
764 {
765 y = rect.bottom - 2 * GetSystemMetrics(SM_CYICONSPACING) - GetSystemMetrics(SM_CYICON);
766 rect.bottom = ( y - GetSystemMetrics(SM_CYICON) < rect.top )? rect.bottom: y;
767 }
768
769 ysize = rect.bottom / rows;
770 xsize = rect.right / columns;
771
772 for (x = i = 0, c = 1; c <= columns && *ppWnd; c++)
773 {
774 if (c == columns)
775 {
776 rows = total - i;
777 ysize = rect.bottom / rows;
778 }
779
780 y = 0;
781 for (r = 1; r <= rows && *ppWnd; r++, i++)
782 {
783 SetWindowPos((*ppWnd)->hwndSelf, 0, x, y, xsize, ysize,
784 SWP_DRAWFRAME | SWP_NOACTIVATE | SWP_NOZORDER);
785 y += ysize;
786 ppWnd++;
787 }
788 x += xsize;
789 }
790 }
791 WIN_ReleaseWinArray(heapPtr);
792 }
793
794 if( total < ci->nActiveChildren ) ArrangeIconicWindows( wndClient->hwndSelf );
795 }
796
797 /* ----------------------- Frame window ---------------------------- */
798
799
800 /**********************************************************************
801 * MDI_AugmentFrameMenu
802 */
803 static BOOL MDI_AugmentFrameMenu( MDICLIENTINFO* ci, WND *frame,
804 HWND hChild )
805 {
806 WND* child = WIN_FindWndPtr(hChild);
807 HMENU hSysPopup = 0;
808 HBITMAP hSysMenuBitmap = 0;
809
810 TRACE("frame %p,child %04x\n",frame,hChild);
811
812 if( !frame->wIDmenu || !child->hSysMenu )
813 {
814 WIN_ReleaseWndPtr(child);
815 return 0;
816 }
817 WIN_ReleaseWndPtr(child);
818
819 /* create a copy of sysmenu popup and insert it into frame menu bar */
820
821 if (!(hSysPopup = LoadMenuA(GetModuleHandleA("USER32"), "SYSMENU")))
822 return 0;
823
824 TRACE("\tgot popup %04x in sysmenu %04x\n",
825 hSysPopup, child->hSysMenu);
826
827 AppendMenuA(frame->wIDmenu,MF_HELP | MF_BITMAP,
828 SC_MINIMIZE, (LPSTR)(DWORD)HBMMENU_MBAR_MINIMIZE ) ;
829 AppendMenuA(frame->wIDmenu,MF_HELP | MF_BITMAP,
830 SC_RESTORE, (LPSTR)(DWORD)HBMMENU_MBAR_RESTORE );
831
832 /* In Win 95 look, the system menu is replaced by the child icon */
833
834 if(TWEAK_WineLook > WIN31_LOOK)
835 {
836 HICON hIcon = GetClassLongA(hChild, GCL_HICONSM);
837 if (!hIcon)
838 hIcon = GetClassLongA(hChild, GCL_HICON);
839 if (hIcon)
840 {
841 HDC hMemDC;
842 HBITMAP hBitmap, hOldBitmap;
843 HBRUSH hBrush;
844 HDC hdc = GetDC(hChild);
845
846 if (hdc)
847 {
848 int cx, cy;
849 cx = GetSystemMetrics(SM_CXSMICON);
850 cy = GetSystemMetrics(SM_CYSMICON);
851 hMemDC = CreateCompatibleDC(hdc);
852 hBitmap = CreateCompatibleBitmap(hdc, cx, cy);
853 hOldBitmap = SelectObject(hMemDC, hBitmap);
854 SetMapMode(hMemDC, MM_TEXT);
855 hBrush = CreateSolidBrush(GetSysColor(COLOR_MENU));
856 DrawIconEx(hMemDC, 0, 0, hIcon, cx, cy, 0, hBrush, DI_NORMAL);
857 SelectObject (hMemDC, hOldBitmap);
858 DeleteObject(hBrush);
859 DeleteDC(hMemDC);
860 ReleaseDC(hChild, hdc);
861 hSysMenuBitmap = hBitmap;
862 }
863 }
864 }
865 else
866 hSysMenuBitmap = hBmpClose;
867
868 if( !InsertMenuA(frame->wIDmenu,0,MF_BYPOSITION | MF_BITMAP | MF_POPUP,
869 hSysPopup, (LPSTR)(DWORD)hSysMenuBitmap))
870 {
871 TRACE("not inserted\n");
872 DestroyMenu(hSysPopup);
873 return 0;
874 }
875
876 /* The close button is only present in Win 95 look */
877 if(TWEAK_WineLook > WIN31_LOOK)
878 {
879 AppendMenuA(frame->wIDmenu,MF_HELP | MF_BITMAP,
880 SC_CLOSE, (LPSTR)(DWORD)HBMMENU_MBAR_CLOSE );
881 }
882
883 EnableMenuItem(hSysPopup, SC_SIZE, MF_BYCOMMAND | MF_GRAYED);
884 EnableMenuItem(hSysPopup, SC_MOVE, MF_BYCOMMAND | MF_GRAYED);
885 EnableMenuItem(hSysPopup, SC_MAXIMIZE, MF_BYCOMMAND | MF_GRAYED);
886 SetMenuDefaultItem(hSysPopup, SC_CLOSE, FALSE);
887
888 /* redraw menu */
889 DrawMenuBar(frame->hwndSelf);
890
891 return 1;
892 }
893
894 /**********************************************************************
895 * MDI_RestoreFrameMenu
896 */
897 static BOOL MDI_RestoreFrameMenu( WND *frameWnd, HWND hChild )
898 {
899 MENUITEMINFOA menuInfo;
900 INT nItems = GetMenuItemCount(frameWnd->wIDmenu) - 1;
901 UINT iId = GetMenuItemID(frameWnd->wIDmenu,nItems) ;
902
903 TRACE("frameWnd %p,child %04x\n",frameWnd,hChild);
904
905 if(!(iId == SC_RESTORE || iId == SC_CLOSE) )
906 return 0;
907
908 /*
909 * Remove the system menu, If that menu is the icon of the window
910 * as it is in win95, we have to delete the bitmap.
911 */
912 menuInfo.cbSize = sizeof(MENUITEMINFOA);
913 menuInfo.fMask = MIIM_DATA | MIIM_TYPE;
914
915 GetMenuItemInfoA(frameWnd->wIDmenu,
916 0,
917 TRUE,
918 &menuInfo);
919
920 RemoveMenu(frameWnd->wIDmenu,0,MF_BYPOSITION);
921
922 if ( (menuInfo.fType & MFT_BITMAP) &&
923 (LOWORD(menuInfo.dwTypeData)!=0) &&
924 (LOWORD(menuInfo.dwTypeData)!=hBmpClose) )
925 {
926 DeleteObject((HBITMAP)LOWORD(menuInfo.dwTypeData));
927 }
928
929 if(TWEAK_WineLook > WIN31_LOOK)
930 {
931 /* close */
932 DeleteMenu(frameWnd->wIDmenu,GetMenuItemCount(frameWnd->wIDmenu) - 1,MF_BYPOSITION);
933 }
934 /* restore */
935 DeleteMenu(frameWnd->wIDmenu,GetMenuItemCount(frameWnd->wIDmenu) - 1,MF_BYPOSITION);
936 /* minimize */
937 DeleteMenu(frameWnd->wIDmenu,GetMenuItemCount(frameWnd->wIDmenu) - 1,MF_BYPOSITION);
938
939 DrawMenuBar(frameWnd->hwndSelf);
940
941 return 1;
942 }
943
944
945 /**********************************************************************
946 * MDI_UpdateFrameText
947 *
948 * used when child window is maximized/restored
949 *
950 * Note: lpTitle can be NULL
951 */
952 static void MDI_UpdateFrameText( WND *frameWnd, HWND hClient,
953 BOOL repaint, LPCSTR lpTitle )
954 {
955 char lpBuffer[MDI_MAXTITLELENGTH+1];
956 WND* clientWnd = WIN_FindWndPtr(hClient);
957 MDICLIENTINFO *ci = (MDICLIENTINFO *) clientWnd->wExtra;
958
959 TRACE("repaint %i, frameText %s\n", repaint, (lpTitle)?lpTitle:"NULL");
960
961 if (!clientWnd)
962 return;
963
964 if (!ci)
965 {
966 WIN_ReleaseWndPtr(clientWnd);
967 return;
968 }
969
970 /* store new "default" title if lpTitle is not NULL */
971 if (lpTitle)
972 {
973 if (ci->frameTitle) HeapFree( SystemHeap, 0, ci->frameTitle );
974 ci->frameTitle = HEAP_strdupA( SystemHeap, 0, lpTitle );
975 }
976
977 if (ci->frameTitle)
978 {
979 WND* childWnd = WIN_FindWndPtr( ci->hwndChildMaximized );
980
981 if( childWnd && childWnd->text )
982 {
983 /* combine frame title and child title if possible */
984
985 LPCSTR lpBracket = " - [";
986 int i_frame_text_length = strlen(ci->frameTitle);
987 int i_child_text_length = strlen(childWnd->text);
988
989 lstrcpynA( lpBuffer, ci->frameTitle, MDI_MAXTITLELENGTH);
990
991 if( i_frame_text_length + 6 < MDI_MAXTITLELENGTH )
992 {
993 strcat( lpBuffer, lpBracket );
994
995 if( i_frame_text_length + i_child_text_length + 6 < MDI_MAXTITLELENGTH )
996 {
997 strcat( lpBuffer, childWnd->text );
998 strcat( lpBuffer, "]" );
999 }
1000 else
1001 {
1002 lstrcpynA( lpBuffer + i_frame_text_length + 4,
1003 childWnd->text, MDI_MAXTITLELENGTH - i_frame_text_length - 5 );
1004 strcat( lpBuffer, "]" );
1005 }
1006 }
1007 }
1008 else
1009 {
1010 strncpy(lpBuffer, ci->frameTitle, MDI_MAXTITLELENGTH );
1011 lpBuffer[MDI_MAXTITLELENGTH]='\0';
1012 }
1013 WIN_ReleaseWndPtr(childWnd);
1014
1015 }
1016 else
1017 lpBuffer[0] = '\0';
1018
1019 DEFWND_SetText( frameWnd, lpBuffer );
1020 if( repaint == MDI_REPAINTFRAME)
1021 SetWindowPos( frameWnd->hwndSelf, 0,0,0,0,0, SWP_FRAMECHANGED |
1022 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER );
1023
1024 WIN_ReleaseWndPtr(clientWnd);
1025
1026 }
1027
1028
1029 /* ----------------------------- Interface ---------------------------- */
1030
1031
1032 /**********************************************************************
1033 * MDIClientWndProc
1034 *
1035 * This function handles all MDI requests.
1036 */
1037 LRESULT WINAPI MDIClientWndProc( HWND hwnd, UINT message, WPARAM wParam,
1038 LPARAM lParam )
1039 {
1040 LPCREATESTRUCTA cs;
1041 MDICLIENTINFO *ci;
1042 RECT rect;
1043 WND *w, *frameWnd;
1044 INT nItems;
1045 LRESULT retvalue;
1046
1047 if ( ( w = WIN_FindWndPtr(hwnd) ) == NULL )
1048 return 0;
1049
1050 if ( ( frameWnd = WIN_LockWndPtr(w->parent) ) == NULL ) {
1051 WIN_ReleaseWndPtr(w);
1052 return 0;
1053 }
1054
1055 ci = (MDICLIENTINFO *) w->wExtra;
1056
1057 switch (message)
1058 {
1059 case WM_CREATE:
1060
1061 cs = (LPCREATESTRUCTA)lParam;
1062
1063 /* Translation layer doesn't know what's in the cs->lpCreateParams
1064 * so we have to keep track of what environment we're in. */
1065
1066 if( w->flags & WIN_ISWIN32 )
1067 {
1068 #define ccs ((LPCLIENTCREATESTRUCT)cs->lpCreateParams)
1069 ci->hWindowMenu = ccs->hWindowMenu;
1070 ci->idFirstChild = ccs->idFirstChild;
1071 #undef ccs
1072 }
1073 else
1074 {
1075 LPCLIENTCREATESTRUCT16 ccs = (LPCLIENTCREATESTRUCT16)
1076 PTR_SEG_TO_LIN(cs->lpCreateParams);
1077 ci->hWindowMenu = ccs->hWindowMenu;
1078 ci->idFirstChild = ccs->idFirstChild;
1079 }
1080
1081 ci->hwndChildMaximized = 0;
1082 ci->nActiveChildren = 0;
1083 ci->nTotalCreated = 0;
1084 ci->frameTitle = NULL;
1085 ci->mdiFlags = 0;
1086 ci->self = hwnd;
1087 w->dwStyle |= WS_CLIPCHILDREN;
1088
1089 if (!hBmpClose)
1090 {
1091 hBmpClose = CreateMDIMenuBitmap();
1092 hBmpRestore = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_RESTORE) );
1093 }
1094 MDI_UpdateFrameText(frameWnd, hwnd, MDI_NOFRAMEREPAINT,frameWnd->text);
1095
1096 AppendMenuA( ci->hWindowMenu, MF_SEPARATOR, 0, NULL );
1097
1098 GetClientRect(frameWnd->hwndSelf, &rect);
1099 NC_HandleNCCalcSize( w, &rect );
1100 w->rectClient = rect;
1101
1102 TRACE("Client created - hwnd = %04x, idFirst = %u\n",
1103 hwnd, ci->idFirstChild );
1104
1105 retvalue = 0;
1106 goto END;
1107
1108 case WM_DESTROY:
1109 if( ci->hwndChildMaximized ) MDI_RestoreFrameMenu(w, frameWnd->hwndSelf);
1110 if((nItems = GetMenuItemCount(ci->hWindowMenu)) > 0)
1111 {
1112 ci->idFirstChild = nItems - 1;
1113 ci->nActiveChildren++; /* to delete a separator */
1114 while( ci->nActiveChildren-- )
1115 DeleteMenu(ci->hWindowMenu,MF_BYPOSITION,ci->idFirstChild--);
1116 }
1117 retvalue = 0;
1118 goto END;
1119
1120 case WM_MDIACTIVATE:
1121 if( ci->hwndActiveChild != (HWND)wParam )
1122 SetWindowPos((HWND)wParam, 0,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE);
1123 retvalue = 0;
1124 goto END;
1125
1126 case WM_MDICASCADE:
1127 retvalue = MDICascade(w, ci);
1128 goto END;
1129
1130 case WM_MDICREATE:
1131 if (lParam) retvalue = MDICreateChild( w, ci, hwnd,
1132 (MDICREATESTRUCTA*)lParam );
1133 else retvalue = 0;
1134 goto END;
1135
1136 case WM_MDIDESTROY:
1137 retvalue = MDIDestroyChild( w, ci, hwnd, (HWND)wParam, TRUE );
1138 goto END;
1139
1140 case WM_MDIGETACTIVE:
1141 if (lParam) *(BOOL *)lParam = (ci->hwndChildMaximized > 0);
1142 retvalue = ci->hwndActiveChild;
1143 goto END;
1144
1145 case WM_MDIICONARRANGE:
1146 ci->mdiFlags |= MDIF_NEEDUPDATE;
1147 ArrangeIconicWindows(hwnd);
1148 ci->sbRecalc = SB_BOTH+1;
1149 SendMessageA(hwnd, WM_MDICALCCHILDSCROLL, 0, 0L);
1150 retvalue = 0;
1151 goto END;
1152
1153 case WM_MDIMAXIMIZE:
1154 ShowWindow( (HWND)wParam, SW_MAXIMIZE );
1155 retvalue = 0;
1156 goto END;
1157
1158 case WM_MDINEXT: /* lParam != 0 means previous window */
1159 MDI_SwitchActiveChild(hwnd, (HWND)wParam, (lParam)? FALSE : TRUE );
1160 break;
1161
1162 case WM_MDIRESTORE:
1163 SendMessageA( (HWND)wParam, WM_SYSCOMMAND, SC_RESTORE, 0);
1164 retvalue = 0;
1165 goto END;
1166
1167 case WM_MDISETMENU:
1168 retvalue = MDISetMenu( hwnd, (HMENU)wParam, (HMENU)lParam );
1169 goto END;
1170 case WM_MDIREFRESHMENU:
1171 retvalue = MDIRefreshMenu( hwnd, (HMENU)wParam, (HMENU)lParam );
1172 goto END;
1173
1174 case WM_MDITILE:
1175 ci->mdiFlags |= MDIF_NEEDUPDATE;
1176 ShowScrollBar(hwnd,SB_BOTH,FALSE);
1177 MDITile(w, ci, wParam);
1178 ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1179 retvalue = 0;
1180 goto END;
1181
1182 case WM_VSCROLL:
1183 case WM_HSCROLL:
1184 ci->mdiFlags |= MDIF_NEEDUPDATE;
1185 ScrollChildren(hwnd, message, wParam, lParam);
1186 ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1187 retvalue = 0;
1188 goto END;
1189
1190 case WM_SETFOCUS:
1191 if( ci->hwndActiveChild )
1192 {
1193 WND* pw = WIN_FindWndPtr( ci->hwndActiveChild );
1194 if( !(pw->dwStyle & WS_MINIMIZE) )
1195 SetFocus( ci->hwndActiveChild );
1196 WIN_ReleaseWndPtr(pw);
1197 }
1198 retvalue = 0;
1199 goto END;
1200
1201 case WM_NCACTIVATE:
1202 if( ci->hwndActiveChild )
1203 SendMessageA(ci->hwndActiveChild, message, wParam, lParam);
1204 break;
1205
1206 case WM_PARENTNOTIFY:
1207 if (LOWORD(wParam) == WM_LBUTTONDOWN)
1208 {
1209 POINT16 pt = MAKEPOINT16(lParam);
1210 HWND16 child = ChildWindowFromPoint16(hwnd, pt);
1211
1212 TRACE("notification from %04x (%i,%i)\n",child,pt.x,pt.y);
1213
1214 if( child && child != hwnd && child != ci->hwndActiveChild )
1215 SetWindowPos(child, 0,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE );
1216 }
1217 retvalue = 0;
1218 goto END;
1219
1220 case WM_SIZE:
1221 if( IsWindow(ci->hwndChildMaximized) )
1222 {
1223 WND* child = WIN_FindWndPtr(ci->hwndChildMaximized);
1224 RECT rect;
1225
1226 rect.left = 0;
1227 rect.top = 0;
1228 rect.right = LOWORD(lParam);
1229 rect.bottom = HIWORD(lParam);
1230
1231 AdjustWindowRectEx(&rect, child->dwStyle, 0, child->dwExStyle);
1232 MoveWindow(ci->hwndChildMaximized, rect.left, rect.top,
1233 rect.right - rect.left, rect.bottom - rect.top, 1);
1234 WIN_ReleaseWndPtr(child);
1235 }
1236 else
1237 MDI_PostUpdate(hwnd, ci, SB_BOTH+1);
1238
1239 break;
1240
1241 case WM_MDICALCCHILDSCROLL:
1242 if( (ci->mdiFlags & MDIF_NEEDUPDATE) && ci->sbRecalc )
1243 {
1244 CalcChildScroll16(hwnd, ci->sbRecalc-1);
1245 ci->sbRecalc = 0;
1246 ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1247 }
1248 retvalue = 0;
1249 goto END;
1250 }
1251
1252 retvalue = DefWindowProcA( hwnd, message, wParam, lParam );
1253 END:
1254 WIN_ReleaseWndPtr(w);
1255 WIN_ReleaseWndPtr(frameWnd);
1256 return retvalue;
1257 }
1258
1259
1260 /***********************************************************************
1261 * DefFrameProc16 (USER.445)
1262 */
1263 LRESULT WINAPI DefFrameProc16( HWND16 hwnd, HWND16 hwndMDIClient,
1264 UINT16 message, WPARAM16 wParam, LPARAM lParam )
1265 {
1266 HWND16 childHwnd;
1267 MDICLIENTINFO* ci;
1268 WND* wndPtr;
1269
1270 if (hwndMDIClient)
1271 {
1272 switch (message)
1273 {
1274 case WM_COMMAND:
1275 wndPtr = WIN_FindWndPtr(hwndMDIClient);
1276
1277 if (!wndPtr) {
1278 ERR("null wndPtr for mdi window hwndMDIClient=%04x\n",
1279 hwndMDIClient);
1280 return 0;
1281 }
1282
1283 ci = (MDICLIENTINFO*)wndPtr->wExtra;
1284
1285 /* check for possible syscommands for maximized MDI child */
1286 WIN_ReleaseWndPtr(wndPtr);
1287
1288 if( ci && (
1289 wParam < ci->idFirstChild ||
1290 wParam >= ci->idFirstChild + ci->nActiveChildren
1291 )){
1292 if( (wParam - 0xF000) & 0xF00F ) break;
1293 switch( wParam )
1294 {
1295 case SC_SIZE:
1296 case SC_MOVE:
1297 case SC_MINIMIZE:
1298 case SC_MAXIMIZE:
1299 case SC_NEXTWINDOW:
1300 case SC_PREVWINDOW:
1301 case SC_CLOSE:
1302 case SC_RESTORE:
1303 if( ci->hwndChildMaximized )
1304 return SendMessage16( ci->hwndChildMaximized, WM_SYSCOMMAND,
1305 wParam, lParam);
1306 }
1307 }
1308 else
1309 {
1310 wndPtr = WIN_FindWndPtr(hwndMDIClient);
1311 childHwnd = MDI_GetChildByID(wndPtr,wParam );
1312 WIN_ReleaseWndPtr(wndPtr);
1313
1314 if( childHwnd )
1315 SendMessage16(hwndMDIClient, WM_MDIACTIVATE,
1316 (WPARAM16)childHwnd , 0L);
1317 }
1318 break;
1319
1320 case WM_NCACTIVATE:
1321 SendMessage16(hwndMDIClient, message, wParam, lParam);
1322 break;
1323
1324 case WM_SETTEXT:
1325 wndPtr = WIN_FindWndPtr(hwnd);
1326 MDI_UpdateFrameText(wndPtr, hwndMDIClient,
1327 MDI_REPAINTFRAME,
1328 (LPCSTR)PTR_SEG_TO_LIN(lParam));
1329 WIN_ReleaseWndPtr(wndPtr);
1330 return 0;
1331
1332 case WM_SETFOCUS:
1333 SetFocus(hwndMDIClient);
1334 break;
1335
1336 case WM_SIZE:
1337 MoveWindow16(hwndMDIClient, 0, 0,
1338 LOWORD(lParam), HIWORD(lParam), TRUE);
1339 break;
1340
1341 case WM_NEXTMENU:
1342
1343 wndPtr = WIN_FindWndPtr(hwndMDIClient);
1344 ci = (MDICLIENTINFO*)wndPtr->wExtra;
1345
1346 if( !(wndPtr->parent->dwStyle & WS_MINIMIZE)
1347 && ci->hwndActiveChild && !ci->hwndChildMaximized )
1348 {
1349 /* control menu is between the frame system menu and
1350 * the first entry of menu bar */
1351
1352 if( (wParam == VK_LEFT &&
1353 wndPtr->parent->wIDmenu == LOWORD(lParam)) ||
1354 (wParam == VK_RIGHT &&
1355 GetSubMenu16(wndPtr->parent->hSysMenu, 0) == LOWORD(lParam)) )
1356 {
1357 LRESULT retvalue;
1358 WIN_ReleaseWndPtr(wndPtr);
1359 wndPtr = WIN_FindWndPtr(ci->hwndActiveChild);
1360 retvalue = MAKELONG( GetSubMenu16(wndPtr->hSysMenu, 0),
1361 ci->hwndActiveChild);
1362 WIN_ReleaseWndPtr(wndPtr);
1363 return retvalue;
1364 }
1365 }
1366 WIN_ReleaseWndPtr(wndPtr);
1367 break;
1368 }
1369 }
1370
1371 return DefWindowProc16(hwnd, message, wParam, lParam);
1372 }
1373
1374
1375 /***********************************************************************
1376 * DefFrameProc32A (USER32.122)
1377 */
1378 LRESULT WINAPI DefFrameProcA( HWND hwnd, HWND hwndMDIClient,
1379 UINT message, WPARAM wParam, LPARAM lParam)
1380 {
1381 if (hwndMDIClient)
1382 {
1383 switch (message)
1384 {
1385 case WM_COMMAND:
1386 return DefFrameProc16( hwnd, hwndMDIClient, message,
1387 (WPARAM16)wParam,
1388 MAKELPARAM( (HWND16)lParam, HIWORD(wParam) ) );
1389
1390 case WM_NCACTIVATE:
1391 SendMessageA(hwndMDIClient, message, wParam, lParam);
1392 break;
1393
1394 case WM_SETTEXT: {
1395 LRESULT ret;
1396 LPSTR segstr = SEGPTR_STRDUP((LPSTR)lParam);
1397
1398 ret = DefFrameProc16(hwnd, hwndMDIClient, message,
1399 wParam, (LPARAM)SEGPTR_GET(segstr) );
1400 SEGPTR_FREE(segstr);
1401 return ret;
1402 }
1403
1404 case WM_NEXTMENU:
1405 case WM_SETFOCUS:
1406 case WM_SIZE:
1407 return DefFrameProc16( hwnd, hwndMDIClient, message,
1408 wParam, lParam );
1409 }
1410 }
1411
1412 return DefWindowProcA(hwnd, message, wParam, lParam);
1413 }
1414
1415
1416 /***********************************************************************
1417 * DefFrameProc32W (USER32.123)
1418 */
1419 LRESULT WINAPI DefFrameProcW( HWND hwnd, HWND hwndMDIClient,
1420 UINT message, WPARAM wParam, LPARAM lParam)
1421 {
1422 if (hwndMDIClient)
1423 {
1424 switch (message)
1425 {
1426 case WM_COMMAND:
1427 return DefFrameProc16( hwnd, hwndMDIClient, message,
1428 (WPARAM16)wParam,
1429 MAKELPARAM( (HWND16)lParam, HIWORD(wParam) ) );
1430
1431 case WM_NCACTIVATE:
1432 SendMessageW(hwndMDIClient, message, wParam, lParam);
1433 break;
1434
1435 case WM_SETTEXT:
1436 {
1437 LPSTR txt = HEAP_strdupWtoA(GetProcessHeap(),0,(LPWSTR)lParam);
1438 LRESULT ret = DefFrameProcA( hwnd, hwndMDIClient, message,
1439 wParam, (DWORD)txt );
1440 HeapFree(GetProcessHeap(),0,txt);
1441 return ret;
1442 }
1443 case WM_NEXTMENU:
1444 case WM_SETFOCUS:
1445 case WM_SIZE:
1446 return DefFrameProcA( hwnd, hwndMDIClient, message,
1447 wParam, lParam );
1448 }
1449 }
1450
1451 return DefWindowProcW( hwnd, message, wParam, lParam );
1452 }
1453
1454
1455 /***********************************************************************
1456 * DefMDIChildProc16 (USER.447)
1457 */
1458 LRESULT WINAPI DefMDIChildProc16( HWND16 hwnd, UINT16 message,
1459 WPARAM16 wParam, LPARAM lParam )
1460 {
1461 MDICLIENTINFO *ci;
1462 WND *clientWnd,*tmpWnd = 0;
1463 LRESULT retvalue;
1464
1465 clientWnd = WIN_FindWndPtr(GetParent16(hwnd));
1466 ci = (MDICLIENTINFO *) clientWnd->wExtra;
1467
1468 switch (message)
1469 {
1470 case WM_SETTEXT:
1471 DefWindowProc16(hwnd, message, wParam, lParam);
1472 MDI_MenuModifyItem(clientWnd,hwnd);
1473 if( ci->hwndChildMaximized == hwnd )
1474 MDI_UpdateFrameText( clientWnd->parent, ci->self,
1475 MDI_REPAINTFRAME, NULL );
1476 retvalue = 0;
1477 goto END;
1478
1479 case WM_CLOSE:
1480 SendMessage16(ci->self,WM_MDIDESTROY,(WPARAM16)hwnd,0L);
1481 retvalue = 0;
1482 goto END;
1483
1484 case WM_SETFOCUS:
1485 if( ci->hwndActiveChild != hwnd )
1486 MDI_ChildActivate(clientWnd, hwnd);
1487 break;
1488
1489 case WM_CHILDACTIVATE:
1490 MDI_ChildActivate(clientWnd, hwnd);
1491 retvalue = 0;
1492 goto END;
1493
1494 case WM_NCPAINT:
1495 TRACE("WM_NCPAINT for %04x, active %04x\n",
1496 hwnd, ci->hwndActiveChild );
1497 break;
1498
1499 case WM_SYSCOMMAND:
1500 switch( wParam )
1501 {
1502 case SC_MOVE:
1503 if( ci->hwndChildMaximized == hwnd)
1504 {
1505 retvalue = 0;
1506 goto END;
1507 }
1508 break;
1509 case SC_RESTORE:
1510 case SC_MINIMIZE:
1511 tmpWnd = WIN_FindWndPtr(hwnd);
1512 tmpWnd->dwStyle |= WS_SYSMENU;
1513 WIN_ReleaseWndPtr(tmpWnd);
1514 break;
1515 case SC_MAXIMIZE:
1516 if( ci->hwndChildMaximized == hwnd)
1517 {
1518 retvalue = SendMessage16( clientWnd->parent->hwndSelf,
1519 message, wParam, lParam);
1520 goto END;
1521 }
1522 tmpWnd = WIN_FindWndPtr(hwnd);
1523 tmpWnd->dwStyle &= ~WS_SYSMENU;
1524 WIN_ReleaseWndPtr(tmpWnd);
1525 break;
1526 case SC_NEXTWINDOW:
1527 SendMessage16( ci->self, WM_MDINEXT, 0, 0);
1528 retvalue = 0;
1529 goto END;
1530 case SC_PREVWINDOW:
1531 SendMessage16( ci->self, WM_MDINEXT, 0, 1);
1532 retvalue = 0;
1533 goto END;
1534 }
1535 break;
1536
1537 case WM_GETMINMAXINFO:
1538 MDI_ChildGetMinMaxInfo(clientWnd, hwnd, (MINMAXINFO16*) PTR_SEG_TO_LIN(lParam));
1539 retvalue = 0;
1540 goto END;
1541
1542 case WM_SETVISIBLE:
1543 if( ci->hwndChildMaximized) ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1544 else
1545 MDI_PostUpdate(clientWnd->hwndSelf, ci, SB_BOTH+1);
1546 break;
1547
1548 case WM_SIZE:
1549 /* do not change */
1550
1551 if( ci->hwndActiveChild == hwnd && wParam != SIZE_MAXIMIZED )
1552 {
1553 ci->hwndChildMaximized = 0;
1554
1555 MDI_RestoreFrameMenu( clientWnd->parent, hwnd);
1556 MDI_UpdateFrameText( clientWnd->parent, ci->self,
1557 MDI_REPAINTFRAME, NULL );
1558 }
1559
1560 if( wParam == SIZE_MAXIMIZED )
1561 {
1562 HWND16 hMaxChild = ci->hwndChildMaximized;
1563
1564 if( hMaxChild == hwnd ) break;
1565
1566 if( hMaxChild)
1567 {
1568 SendMessage16( hMaxChild, WM_SETREDRAW, FALSE, 0L );
1569
1570 MDI_RestoreFrameMenu( clientWnd->parent, hMaxChild);
1571 ShowWindow16( hMaxChild, SW_SHOWNOACTIVATE);
1572
1573 SendMessage16( hMaxChild, WM_SETREDRAW, TRUE, 0L );
1574 }
1575
1576 TRACE("maximizing child %04x\n", hwnd );
1577
1578 ci->hwndChildMaximized = hwnd; /* !!! */
1579 ci->hwndActiveChild = hwnd;
1580
1581 MDI_AugmentFrameMenu( ci, clientWnd->parent, hwnd);
1582 MDI_UpdateFrameText( clientWnd->parent, ci->self,
1583 MDI_REPAINTFRAME, NULL );
1584 }
1585
1586 if( wParam == SIZE_MINIMIZED )
1587 {
1588 HWND16 switchTo = MDI_GetWindow(clientWnd, hwnd, TRUE, WS_MINIMIZE);
1589
1590 if( switchTo )
1591 SendMessage16( switchTo, WM_CHILDACTIVATE, 0, 0L);
1592 }
1593
1594 MDI_PostUpdate(clientWnd->hwndSelf, ci, SB_BOTH+1);
1595 break;
1596
1597 case WM_MENUCHAR:
1598
1599 /* MDI children don't have menu bars */
1600 PostMessage16( clientWnd->parent->hwndSelf, WM_SYSCOMMAND,
1601 (WPARAM16)SC_KEYMENU, (LPARAM)wParam);
1602 retvalue = 0x00010000L;
1603 goto END;
1604
1605 case WM_NEXTMENU:
1606
1607 if( wParam == VK_LEFT ) /* switch to frame system menu */
1608 {
1609 retvalue = MAKELONG( GetSubMenu16(clientWnd->parent->hSysMenu, 0),
1610 clientWnd->parent->hwndSelf );
1611 goto END;
1612 }
1613 if( wParam == VK_RIGHT ) /* to frame menu bar */
1614 {
1615 retvalue = MAKELONG( clientWnd->parent->wIDmenu,
1616 clientWnd->parent->hwndSelf );
1617 goto END;
1618 }
1619
1620 break;
1621
1622 case WM_SYSCHAR:
1623 if (wParam == '-')
1624 {
1625 SendMessage16(hwnd,WM_SYSCOMMAND,
1626 (WPARAM16)SC_KEYMENU, (LPARAM)(DWORD)VK_SPACE);
1627 retvalue = 0;
1628 goto END;
1629 }
1630 }
1631
1632 retvalue = DefWindowProc16(hwnd, message, wParam, lParam);
1633 END:
1634 WIN_ReleaseWndPtr(clientWnd);
1635 return retvalue;
1636 }
1637
1638
1639 /***********************************************************************
1640 * DefMDIChildProc32A (USER32.124)
1641 */
1642 LRESULT WINAPI DefMDIChildProcA( HWND hwnd, UINT message,
1643 WPARAM wParam, LPARAM lParam )
1644 {
1645 MDICLIENTINFO *ci;
1646 WND *clientWnd,*tmpWnd;
1647 LRESULT retvalue;
1648
1649 tmpWnd = WIN_FindWndPtr(hwnd);
1650 clientWnd = WIN_FindWndPtr(tmpWnd->parent->hwndSelf);
1651 ci = (MDICLIENTINFO *) clientWnd->wExtra;
1652 WIN_ReleaseWndPtr(tmpWnd);
1653
1654 switch (message)
1655 {
1656 case WM_SETTEXT:
1657 DefWindowProcA(hwnd, message, wParam, lParam);
1658 MDI_MenuModifyItem(clientWnd,hwnd);
1659 if( ci->hwndChildMaximized == hwnd )
1660 MDI_UpdateFrameText( clientWnd->parent, ci->self,
1661 MDI_REPAINTFRAME, NULL );
1662 retvalue = 0;
1663 goto END;
1664
1665 case WM_GETMINMAXINFO:
1666 {
1667 MINMAXINFO16 mmi;
1668 STRUCT32_MINMAXINFO32to16( (MINMAXINFO *)lParam, &mmi );
1669 MDI_ChildGetMinMaxInfo( clientWnd, hwnd, &mmi );
1670 STRUCT32_MINMAXINFO16to32( &mmi, (MINMAXINFO *)lParam );
1671 }
1672 retvalue = 0;
1673 goto END;
1674
1675 case WM_MENUCHAR:
1676
1677 /* MDI children don't have menu bars */
1678 PostMessage16( clientWnd->parent->hwndSelf, WM_SYSCOMMAND,
1679 (WPARAM16)SC_KEYMENU, (LPARAM)LOWORD(wParam) );
1680 retvalue = 0x00010000L;
1681 goto END;
1682
1683 case WM_CLOSE:
1684 case WM_SETFOCUS:
1685 case WM_CHILDACTIVATE:
1686 case WM_NCPAINT:
1687 case WM_SYSCOMMAND:
1688 case WM_SETVISIBLE:
1689 case WM_SIZE:
1690 case WM_NEXTMENU:
1691 retvalue = DefMDIChildProc16( hwnd, message, (WPARAM16)wParam, lParam );
1692 goto END;
1693
1694 case WM_SYSCHAR:
1695 if (wParam == '-')
1696 {
1697 SendMessageA(hwnd,WM_SYSCOMMAND,
1698 (WPARAM)SC_KEYMENU, (LPARAM)(DWORD)VK_SPACE);
1699 retvalue = 0;
1700 goto END;
1701 }
1702 }
1703 retvalue = DefWindowProcA(hwnd, message, wParam, lParam);
1704 END:
1705 WIN_ReleaseWndPtr(clientWnd);
1706 return retvalue;
1707 }
1708
1709
1710 /***********************************************************************
1711 * DefMDIChildProc32W (USER32.125)
1712 */
1713 LRESULT WINAPI DefMDIChildProcW( HWND hwnd, UINT message,
1714 WPARAM wParam, LPARAM lParam )
1715 {
1716 MDICLIENTINFO *ci;
1717 WND *clientWnd;
1718 LRESULT retvalue;
1719
1720 clientWnd = WIN_FindWndPtr(GetParent16(hwnd));
1721 ci = (MDICLIENTINFO *) clientWnd->wExtra;
1722
1723 switch (message)
1724 {
1725 case WM_SETTEXT:
1726 DefWindowProcW(hwnd, message, wParam, lParam);
1727 MDI_MenuModifyItem(clientWnd,hwnd);
1728 if( ci->hwndChildMaximized == hwnd )
1729 MDI_UpdateFrameText( clientWnd->parent, ci->self,
1730 MDI_REPAINTFRAME, NULL );
1731 retvalue = 0;
1732 goto END;
1733
1734 case WM_GETMINMAXINFO:
1735 case WM_MENUCHAR:
1736 case WM_CLOSE:
1737 case WM_SETFOCUS:
1738 case WM_CHILDACTIVATE:
1739 case WM_NCPAINT:
1740 case WM_SYSCOMMAND:
1741 case WM_SETVISIBLE:
1742 case WM_SIZE:
1743 case WM_NEXTMENU:
1744 retvalue = DefMDIChildProcA( hwnd, message, (WPARAM16)wParam, lParam );
1745 goto END;
1746
1747 case WM_SYSCHAR:
1748 if (wParam == '-')
1749 {
1750 SendMessageW(hwnd,WM_SYSCOMMAND,
1751 (WPARAM)SC_KEYMENU, (LPARAM)(DWORD)VK_SPACE);
1752 retvalue = 0;
1753 goto END;
1754 }
1755 }
1756 retvalue = DefWindowProcW(hwnd, message, wParam, lParam);
1757 END:
1758 WIN_ReleaseWndPtr(clientWnd);
1759 return retvalue;
1760
1761 }
1762
1763
1764 /**********************************************************************
1765 * CreateMDIWindowA [USER32.79] Creates a MDI child in new thread
1766 * FIXME: its in the same thread now
1767 *
1768 * RETURNS
1769 * Success: Handle to created window
1770 * Failure: NULL
1771 */
1772 HWND WINAPI CreateMDIWindowA(
1773 LPCSTR lpClassName, /* [in] Pointer to registered child class name */
1774 LPCSTR lpWindowName, /* [in] Pointer to window name */
1775 DWORD dwStyle, /* [in] Window style */
1776 INT X, /* [in] Horizontal position of window */
1777 INT Y, /* [in] Vertical position of window */
1778 INT nWidth, /* [in] Width of window */
1779 INT nHeight, /* [in] Height of window */
1780 HWND hWndParent, /* [in] Handle to parent window */
1781 HINSTANCE hInstance, /* [in] Handle to application instance */
1782 LPARAM lParam) /* [in] Application-defined value */
1783 {
1784 WARN("is only single threaded!\n");
1785 return MDI_CreateMDIWindowA(lpClassName, lpWindowName, dwStyle, X, Y,
1786 nWidth, nHeight, hWndParent, hInstance, lParam);
1787 }
1788
1789 /**********************************************************************
1790 * MDI_CreateMDIWindowA
1791 * single threaded version of CreateMDIWindowA
1792 * called by CreateWindowEx32A
1793 */
1794 HWND MDI_CreateMDIWindowA(
1795 LPCSTR lpClassName,
1796 LPCSTR lpWindowName,
1797 DWORD dwStyle,
1798 INT X,
1799 INT Y,
1800 INT nWidth,
1801 INT nHeight,
1802 HWND hWndParent,
1803 HINSTANCE hInstance,
1804 LPARAM lParam)
1805 {
1806 MDICLIENTINFO* pCi;
1807 MDICREATESTRUCTA cs;
1808 WND *pWnd=WIN_FindWndPtr(hWndParent);
1809 HWND retvalue;
1810
1811 TRACE("(%s,%s,%ld,%d,%d,%d,%d,%x,%d,%ld)\n",
1812 debugstr_a(lpClassName),debugstr_a(lpWindowName),dwStyle,X,Y,
1813 nWidth,nHeight,hWndParent,hInstance,lParam);
1814
1815 if(!pWnd){
1816 ERR(" bad hwnd for MDI-client: %d\n",hWndParent);
1817 return 0;
1818 }
1819 cs.szClass=lpClassName;
1820 cs.szTitle=lpWindowName;
1821 cs.hOwner=hInstance;
1822 cs.x=X;
1823 cs.y=Y;
1824 cs.cx=nWidth;
1825 cs.cy=nHeight;
1826 cs.style=dwStyle;
1827 cs.lParam=lParam;
1828
1829 pCi=(MDICLIENTINFO *)pWnd->wExtra;
1830
1831 retvalue = MDICreateChild(pWnd,pCi,hWndParent,&cs);
1832 WIN_ReleaseWndPtr(pWnd);
1833 return retvalue;
1834 }
1835
1836 /***************************************
1837 * CreateMDIWindow32W [USER32.80] Creates a MDI child in new thread
1838 *
1839 * RETURNS
1840 * Success: Handle to created window
1841 * Failure: NULL
1842 */
1843 HWND WINAPI CreateMDIWindowW(
1844 LPCWSTR lpClassName, /* [in] Pointer to registered child class name */
1845 LPCWSTR lpWindowName, /* [in] Pointer to window name */
1846 DWORD dwStyle, /* [in] Window style */
1847 INT X, /* [in] Horizontal position of window */
1848 INT Y, /* [in] Vertical position of window */
1849 INT nWidth, /* [in] Width of window */
1850 INT nHeight, /* [in] Height of window */
1851 HWND hWndParent, /* [in] Handle to parent window */
1852 HINSTANCE hInstance, /* [in] Handle to application instance */
1853 LPARAM lParam) /* [in] Application-defined value */
1854 {
1855 FIXME("(%s,%s,%ld,%d,%d,%d,%d,%x,%d,%ld): stub\n",
1856 debugstr_w(lpClassName),debugstr_w(lpWindowName),dwStyle,X,Y,
1857 nWidth,nHeight,hWndParent,hInstance,lParam);
1858 return (HWND)NULL;
1859 }
1860
1861
1862 /******************************************************************************
1863 * CreateMDIWindow32W [USER32.80] Creates a MDI child window
1864 * single threaded version of CreateMDIWindow
1865 * called by CreateWindowEx32W().
1866 */
1867 HWND MDI_CreateMDIWindowW(
1868 LPCWSTR lpClassName, /* [in] Pointer to registered child class name */
1869 LPCWSTR lpWindowName, /* [in] Pointer to window name */
1870 DWORD dwStyle, /* [in] Window style */
1871 INT X, /* [in] Horizontal position of window */
1872 INT Y, /* [in] Vertical position of window */
1873 INT nWidth, /* [in] Width of window */
1874 INT nHeight, /* [in] Height of window */
1875 HWND hWndParent, /* [in] Handle to parent window */
1876 HINSTANCE hInstance, /* [in] Handle to application instance */
1877 LPARAM lParam) /* [in] Application-defined value */
1878 {
1879 FIXME("(%s,%s,%ld,%d,%d,%d,%d,%x,%d,%ld): stub\n",
1880 debugstr_w(lpClassName),debugstr_w(lpWindowName),dwStyle,X,Y,
1881 nWidth,nHeight,hWndParent,hInstance,lParam);
1882 return (HWND)NULL;
1883 }
1884
1885
1886 /**********************************************************************
1887 * TranslateMDISysAccel32 (USER32.555)
1888 */
1889 BOOL WINAPI TranslateMDISysAccel( HWND hwndClient, LPMSG msg )
1890 {
1891 MSG16 msg16;
1892
1893 STRUCT32_MSG32to16(msg,&msg16);
1894 /* MDICLIENTINFO is still the same for win32 and win16 ... */
1895 return TranslateMDISysAccel16(hwndClient,&msg16);
1896 }
1897
1898
1899 /**********************************************************************
1900 * TranslateMDISysAccel16 (USER.451)
1901 */
1902 BOOL16 WINAPI TranslateMDISysAccel16( HWND16 hwndClient, LPMSG16 msg )
1903 {
1904
1905 if( IsWindow(hwndClient) && (msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN))
1906 {
1907 MDICLIENTINFO *ci = NULL;
1908 HWND wnd;
1909 WND *clientWnd = WIN_FindWndPtr(hwndClient);
1910
1911 ci = (MDICLIENTINFO*) clientWnd->wExtra;
1912 wnd = ci->hwndActiveChild;
1913
1914 WIN_ReleaseWndPtr(clientWnd);
1915
1916 if( IsWindow(wnd) && !(GetWindowLongA(wnd,GWL_STYLE) & WS_DISABLED) )
1917 {
1918 WPARAM16 wParam = 0;
1919
1920 /* translate if the Ctrl key is down and Alt not. */
1921
1922 if( (GetKeyState(VK_CONTROL) & 0x8000) &&
1923 !(GetKeyState(VK_MENU) & 0x8000))
1924 {
1925 switch( msg->wParam )
1926 {
1927 case VK_F6:
1928 case VK_TAB:
1929 wParam = ( GetKeyState(VK_SHIFT) & 0x8000 )
1930 ? SC_NEXTWINDOW : SC_PREVWINDOW;
1931 break;
1932 case VK_F4:
1933 case VK_RBUTTON:
1934 wParam = SC_CLOSE;
1935 break;
1936 default:
1937 return 0;
1938 }
1939 TRACE("wParam = %04x\n", wParam);
1940 SendMessage16( ci->hwndActiveChild, WM_SYSCOMMAND,
1941 wParam, (LPARAM)msg->wParam);
1942 return 1;
1943 }
1944 }
1945 }
1946 return 0; /* failure */
1947 }
1948
1949
1950 /***********************************************************************
1951 * CalcChildScroll (USER.462)
1952 */
1953 void WINAPI CalcChildScroll16( HWND16 hwnd, WORD scroll )
1954 {
1955 SCROLLINFO info;
1956 RECT childRect, clientRect;
1957 INT vmin, vmax, hmin, hmax, vpos, hpos;
1958 WND *pWnd, *Wnd;
1959
1960 if (!(pWnd = WIN_FindWndPtr( hwnd ))) return;
1961 Wnd = WIN_FindWndPtr(hwnd);
1962 GetClientRect( hwnd, &clientRect );
1963 SetRectEmpty( &childRect );
1964
1965 for ( WIN_UpdateWndPtr(&pWnd,pWnd->child); pWnd; WIN_UpdateWndPtr(&pWnd,pWnd->next))
1966 {
1967 if( pWnd->dwStyle & WS_MAXIMIZE )
1968 {
1969 ShowScrollBar(hwnd, SB_BOTH, FALSE);
1970 WIN_ReleaseWndPtr(pWnd);
1971 WIN_ReleaseWndPtr(Wnd);
1972 return;
1973 }
1974 UnionRect( &childRect, &pWnd->rectWindow, &childRect );
1975 }
1976 WIN_ReleaseWndPtr(pWnd);
1977 UnionRect( &childRect, &clientRect, &childRect );
1978
1979 hmin = childRect.left; hmax = childRect.right - clientRect.right;
1980 hpos = clientRect.left - childRect.left;
1981 vmin = childRect.top; vmax = childRect.bottom - clientRect.bottom;
1982 vpos = clientRect.top - childRect.top;
1983
1984 switch( scroll )
1985 {
1986 case SB_HORZ:
1987 vpos = hpos; vmin = hmin; vmax = hmax;
1988 case SB_VERT:
1989 info.cbSize = sizeof(info);
1990 info.nMax = vmax; info.nMin = vmin; info.nPos = vpos;
1991 info.fMask = SIF_POS | SIF_RANGE;
1992 SetScrollInfo(hwnd, scroll, &info, TRUE);
1993 break;
1994 case SB_BOTH:
1995 SCROLL_SetNCSbState( Wnd, vmin, vmax, vpos,
1996 hmin, hmax, hpos);
1997 }
1998 WIN_ReleaseWndPtr(Wnd);
1999 }
2000
2001
2002 /***********************************************************************
2003 * ScrollChildren16 (USER.463)
2004 */
2005 void WINAPI ScrollChildren16(HWND16 hWnd, UINT16 uMsg, WPARAM16 wParam, LPARAM lParam)
2006 {
2007 ScrollChildren( hWnd, uMsg, wParam, lParam );
2008 }
2009
2010
2011 /***********************************************************************
2012 * ScrollChildren32 (USER32.448)
2013 */
2014 void WINAPI ScrollChildren(HWND hWnd, UINT uMsg, WPARAM wParam,
2015 LPARAM lParam)
2016 {
2017 WND *wndPtr = WIN_FindWndPtr(hWnd);
2018 INT newPos = -1;
2019 INT curPos, length, minPos, maxPos, shift;
2020
2021 if( !wndPtr ) return;
2022
2023 if( uMsg == WM_HSCROLL )
2024 {
2025 GetScrollRange(hWnd,SB_HORZ,&minPos,&maxPos);
2026 curPos = GetScrollPos(hWnd,SB_HORZ);
2027 length = (wndPtr->rectClient.right - wndPtr->rectClient.left)/2;
2028 shift = GetSystemMetrics(SM_CYHSCROLL);
2029 }
2030 else if( uMsg == WM_VSCROLL )
2031 {
2032 GetScrollRange(hWnd,SB_VERT,&minPos,&maxPos);
2033 curPos = GetScrollPos(hWnd,SB_VERT);
2034 length = (wndPtr->rectClient.bottom - wndPtr->rectClient.top)/2;
2035 shift = GetSystemMetrics(SM_CXVSCROLL);
2036 }
2037 else
2038 {
2039 WIN_ReleaseWndPtr(wndPtr);
2040 return;
2041 }
2042
2043 WIN_ReleaseWndPtr(wndPtr);
2044 switch( wParam )
2045 {
2046 case SB_LINEUP:
2047 newPos = curPos - shift;
2048 break;
2049 case SB_LINEDOWN:
2050 newPos = curPos + shift;
2051 break;
2052 case SB_PAGEUP:
2053 newPos = curPos - length;
2054 break;
2055 case SB_PAGEDOWN:
2056 newPos = curPos + length;
2057 break;
2058
2059 case SB_THUMBPOSITION:
2060 newPos = LOWORD(lParam);
2061 break;
2062
2063 case SB_THUMBTRACK:
2064 return;
2065
2066 case SB_TOP:
2067 newPos = minPos;
2068 break;
2069 case SB_BOTTOM:
2070 newPos = maxPos;
2071 break;
2072 case SB_ENDSCROLL:
2073 CalcChildScroll16(hWnd,(uMsg == WM_VSCROLL)?SB_VERT:SB_HORZ);
2074 return;
2075 }
2076
2077 if( newPos > maxPos )
2078 newPos = maxPos;
2079 else
2080 if( newPos < minPos )
2081 newPos = minPos;
2082
2083 SetScrollPos(hWnd, (uMsg == WM_VSCROLL)?SB_VERT:SB_HORZ , newPos, TRUE);
2084
2085 if( uMsg == WM_VSCROLL )
2086 ScrollWindowEx(hWnd ,0 ,curPos - newPos, NULL, NULL, 0, NULL,
2087 SW_INVALIDATE | SW_ERASE | SW_SCROLLCHILDREN );
2088 else
2089 ScrollWindowEx(hWnd ,curPos - newPos, 0, NULL, NULL, 0, NULL,
2090 SW_INVALIDATE | SW_ERASE | SW_SCROLLCHILDREN );
2091 }
2092
2093
2094 /******************************************************************************
2095 * CascadeWindows [USER32.21] Cascades MDI child windows
2096 *
2097 * RETURNS
2098 * Success: Number of cascaded windows.
2099 * Failure: 0
2100 */
2101 WORD WINAPI
2102 CascadeWindows (HWND hwndParent, UINT wFlags, const LPRECT lpRect,
2103 UINT cKids, const HWND *lpKids)
2104 {
2105 FIXME("(0x%08x,0x%08x,...,%u,...): stub\n",
2106 hwndParent, wFlags, cKids);
2107
2108 return 0;
2109 }
2110
2111
2112 /******************************************************************************
2113 * TileWindows [USER32.545] Tiles MDI child windows
2114 *
2115 * RETURNS
2116 * Success: Number of tiled windows.
2117 * Failure: 0
2118 */
2119 WORD WINAPI
2120 TileWindows (HWND hwndParent, UINT wFlags, const LPRECT lpRect,
2121 UINT cKids, const HWND *lpKids)
2122 {
2123 FIXME("(0x%08x,0x%08x,...,%u,...): stub\n",
2124 hwndParent, wFlags, cKids);
2125
2126 return 0;
2127 }
2128
widl and rpcrt4 development