问题的提出
) g z3 J5 S% x) ]5 H. r
0 N5 `% U" i8 Y( C0 k' G9 ^
在一般用MFC编写的程序的窗口客户区中，可能有好几个子窗口(具有WM_CHILD风格的窗口)。上边是工具栏，中间是视图窗口，下边是状态栏。三个窗
口在框架的客户区里和平共处，互不重叠。主框架窗口的尺寸改变了，别的子窗口都能及时调整自己的尺寸以便保持相互位置关系不变，例如状态条窗口总能保持在
主框架客户区底部，并且其宽度总能和主框架客户区宽度一致。工具栏窗口总能停靠在主框架的某一边不变，其宽度或高度总能和主框架客户区的宽度或高度一致，
视图窗口总能填满主框架客户区的剩余空间。
- e$ t' B: C2 L. O& ?
3 Y3 W8 c9 j( G A% H( B. I- R
假如我们自己从CWnd类派生一个窗口类并生成一个窗口，在它的客户区里要生成若干个子窗口，我们想使这些子窗口排列得规规矩矩，互不重叠，当父窗口的尺
寸变了时各个子窗口能适时调整自己的尺寸和位置，使各个子窗口之间的位置大小比例关系不变。当移动其中一个或几个子窗口时，别的子窗口能及时为这个移动了
的子窗口让位。当然我们可以利用api函数里管理窗口的函数来编写自己的管理子窗口的方法。可是如果在父窗口的客户区里有了工具栏，状态条等等子窗口时，
你自己加进来的子窗口还能和这些mfc提供的子窗口融洽相处吗？你如何保证你的子窗口不会覆盖了能够四处停靠的工具栏？当工具栏和状态条消失后你的子窗口
如何才能知道，以便及时调整自己的大小从而覆盖工具栏和状态条腾出的空间？基于文档视图构架的窗口的客户区内还有个视图，你自己硬加上的子窗口能不和视图
窗口争地盘吗？
, ]6 @4 k# d! [; Y
& M4 o& ^5 k7 O) }- m所以必须了解mfc的窗口管理它的客户区的方法。其实，mfc的窗口管理它的客户区的方法是非常简单的：父窗口调用一个函数，子窗口响应一个消息，就这么多。
4 C* \% j+ _: i5 Y! y. ?; r2 n7 i" ^6 f, ]4 p$ p
CWnd::RepositionBars函数和WM_SIZEPARENT消息
9 [- W7 l/ Q8 l ^ I
) e3 R- A5 Y# P
先简述一下mfc的窗口为子窗口分配客户区空间的过程：这一过程是父窗口与子窗口共同协调完成的。父窗口先提供它的客户区内的一块区域，叫做起始可用区
域。然后调用一个函数，在这个函数里，父窗口把这片区域通过一个消息提交给它的第一个子窗口，该子窗口决定自己要占用多大一块，然后在可用区域里把它将占
据的部分划出去，这样可用区域就被切去了一块。父窗口再把这块剩下的可用区域通过同样的消息提交给第二个子窗口，第二个子窗口再根据自己的需要切掉一块。
如此这般，每个子窗口都切去自己所需的一块。最后剩下的可用区域就给最后的子窗口使用。可以看出，除了最后一个子窗口外，其它子窗口都得在消息响应函数里
有自己的算法来决定自己将在可用区域里占据多大一块，最后一个子窗口由于别无选择，所以不需要这样的算法。
* D0 s& z+ {2 ~) o& I
. m$ H. L+ Y4 q: Z8 W0 z当然，初始的可用区域是一个矩形，每次被切割后剩下的可用区域还是一个矩形，不可能是别的形状的。
5 k9 n2 a" j! X+ ~7 B v5 h
0 M2 b, l8 x" x) B1 ~( D举例说来，在一个典型单文
档程序中，父窗口就是从CFrameWnd派生的主框架窗口，最后一个子窗口就是视图窗口，如果用了CSplitterWnd生成分隔条的话，最后一个子
窗口就是拥有分隔条的那个窗口。其它子窗口就是工具栏窗口和状态条窗口，以及可能有的别的控件窗口。
( |5 E3 G$ B" q! s0 R
4 E* `/ `; z/ q# H: {8 q在典型多文档界面程序中，
父窗口就是主框架窗口，最后一个子窗口就是覆盖在主窗口客户区，背景为黑灰色，拥有包含文档的子框架窗口的那个窗口，这是个预定义了窗口类的窗口，它的窗
口类名是“MDIClient”。如果用了CSplitterWnd生成分隔条的话，最后一个子窗口就是拥有分隔条的那个窗口。其它窗口就是工具栏窗口，
状态条窗口以及可能有的别的控件窗口。
! R/ P/ \$ B( ]7 H9 m
7 `4 i, u# k% o$ ]这个函数和消息是：函数CWnd::RepositionBars()以及消息WM_SIZEPARENT。这个消息是mfc自定义的，不是windows自有的。
% R7 m) o: m2 v7 l$ j8 B6 [) s0 I% ~, K% s. G2 k/ h9 g
先简单说明一下这个函数和消息。
% V6 V- n1 w1 l7 R+ D& k8 l$ p8 K
/ G* p1 \& |& z" V1 s( O0 L. g1。函数CWnd::RepositionBars()
6 }3 w8 h" g! v1 f3 O
0 G" H7 [0 `% v' x: }这个函数不是虚函数，所以就无法在派生类里通过覆盖来编制自己的版本了，只能搞懂它的功能，以便能灵活使用。
# @& t: C* A# Q) z% y! A
0 S4 Z6 c9 \" g! m; Q( \. j5 M简单而言，这
个函数的功能是将可用的客户区区域信息放到消息WM_SIZEPARENT的消息参数里，然后枚举本窗口的所有子窗口，给每个子窗口
(除掉一个特定的子窗口，相当于上文提到的最后一个子窗口)都发送这个消息，每个响应这个消息的子窗口都会把可用客户区切去一块。最后把那个特定的子窗口
的尺寸和位置调整到刚好放在最后剩下的可用区域里。
9 d! Z1 x: q4 l! x! E" \3 Y' ~, D, G
9 b% t) @( F* y7 C5 K! \& w
2。消息WM_SIZEPARENT
" L) {' A4 U. h, b+ H( d
) _* g; m2 N( E5 \9 C* O. ?5 k每个欲参与分配客户区的子窗口都要响应这个消息，除非这个子窗口是那个特定的子窗口。
# E* K4 _3 b, P5 L0 G3 ^; Y: b( g# H* B2 S: Y4 |6 a
响应这个消息的子窗口至少要做两件事：1，将可用的父窗口客户区切去自己所占据的一块。2，根据消息参数的指示，将自己的大小和位置调整到刚好容纳到自己所占据的区域里或不做调整。
8 R1 a& E- g* u. ^9 h% g% l$ d- U4 E! X7 {
下面详细介绍一下函数CWnd::RepositionBars()和消息WM_SIZEPARENT。
# m3 m7 Q* x( r4 x/ {; ~. T
6 y0 C* U% u5 K1 R' s
1。函数CWnd::RepositionBars() void RepositionBars( UINT nIDFirst, UINT
nIDLast, UINT nIDLeftOver, UINT nFlag = CWnd::reposDefault, LPRECT
lpRectParam = NULL, LPCRECT lpRectClient = NULL, BOOL bStretch = TRUE
);
9 A( [% e$ r$ c0 `
7 t) m& l' d+ J9 V- D* d1 h参数比较多，但还是比较好懂的。
# z6 Z( c7 y" a6 j1 p) U6 | ~7 O
1 o8 U5 ?. ?! ]7 `0 i5 \
（1）nIDFirst和nIDLast
5 Y. N; F+ [& m1 a2 M, y
4 ~1 T& A/ b6 r. K& }3 J4 t参与分配父窗口客户区的子窗口的id范围。
+ g( X: Y9 S' p, U: {
; F: K' g/ d# N! ]% x' }7 Z每个
WM_CHILD风格的窗口都有个id，这是在窗口创建过程中指定的。函数CWnd::Create()的第六个参数就是这个id。api函数
CreateWindow和
CreateWindowEx里的那个HMENU类型的参数，当窗口的风格里有WM_CHILD时，它不是指的菜单句柄，而是该窗口的id。
9 Y3 a& x3 E. w5 D5 \( d7 k
! J: {! w( b2 BnIDFirst和nIDLast参数指明了：如果一个子窗口的id值大于等于nIDFirst并且小于等于nIDLast，在这个函数中才会给这个子窗口发送 WM_SIZEPARENT消息，这个子窗口才能参与父窗口客户区的分配。
0 m. M' w8 l; h* l8 T0 a9 I2 W+ P u2 ]$ y$ M
（2）nIDLeftOver
+ P2 j) Z( w9 V! N0 Z
/ r% d9 f. Z% h" B M; m
前面说过，有一个特定的子窗口，它不响应WM_SIZEPARENT消息。只有当其它的子窗口都分配完了，它才来捡取父窗口客户区里剩下的那块。 nIDLeftOver正是这个子窗口的id。它也必须大于等于nIDFirst并且小于等于nIDLast。
; q; ~$ ]$ R$ d# l
% o# G# e' g. s+ x1 C! b（3）lpRectClient
4 V5 \4 E- \; a
' f9 a8 d. z) M- W' m Y
这是一个指向RECT结构数据的指针。这个RECT结构里存放的正是父窗口客户区的初始可用区域。随着在该函数里依次给各个子窗口发送
WM_SIZEPARENT消息，每个响应这个消息的子窗口都会切去自己所占据的部分。最后剩下的部分，就是id为nIDLeftOver的子窗口将要占
据的区域了。这个参数可以为NULL，这时初始的可用区域就是整个父窗口客户区。
- f. f; |6 H E2 E6 K) e6 X0 a. J& G2 o% d0 k% n: V$ _
（4）nFlag和lpRectParam
5 o) g2 |* i/ ? y5 E
5 x, |- d* i$ n) q这两个参数放在一起讲比较好。nFlag是该函数的功能标志，它可以有三个值：reposDefault，reposQuery 和reposExtra。
7 Q& q+ R( |. u' ?6 N
: t7 n2 R! B$ d/ n* h+ H9 {当nFlag等于
reposDefault时，RepositionBars函数的功能是这样的：依次给id介于nIDFirst和nIDLast之间并且不等于
nIDLeftOver的子窗口发送WM_SIZEPARENT消息，每个响应这个消息的子窗口从lpRectClient所指的结构里切去自己所占据的
部分，并且将自己的大小和位置调整到自己所占据的区域的大小，最后RepositionBars函数还将id为nIDLeftOver的子窗口的大小和位
置调整到被其他子窗口切剩的可用区域内，使这个子窗口正好完全覆盖最后的可用区域。这种情况下lpRectParam不用，可以为NULL。
2 \# R$ @# ] F6 M9 D6 A( k* ]2 J, f" \
当nFlag等于reposQuery
时，RepositionBars函数的功能是这样的：依次给id介于nIDFirst和nIDLast之间并且不等于nIDLeftOver的子窗口发
送WM_SIZEPARENT消息，每个响应这个消息的子窗口从lpRectClient所指的结构里切去自己所占据的部分，但是他们并不调整自己的大小
和位置，最后RepositionBars函数并不调整将id为nIDLeftOver的子窗口的大小和位置，而是根据bStretch的值来做动作：如
果bStretch为TRUE，那么
RepositionBars函数把最后剩下的可用区域拷贝到lpRectParam指向的RECT结构里；如果bStretch为FALSE，那么
RepositionBars函数把所有其他子窗口占用掉的可用区域的高和宽(要所有的子窗口都紧排在一起，形成一个大的矩形，这个值才有意义)拷贝到
lpRectParam指向的RECT结构的bottom
和right成员里，其top和left成员被置零。使用这个nFlag值来调用RepositionBars的目的不是要重排子窗口，而是要看看，假如
重排子窗口的话，这些子窗口将占去多大一块，最后剩下的可用区域在什么位置等等信息。
E8 g7 h6 o! o! A4 V/ I
/ S" Q0 h% o7 M' U* E" w, J0 P! p
当nFlag等于reposExtra时，该函数的功能和nFlag等于reposDefault时差不多，有点小小的区别。此时需要用到
lpRectParam。前面说过，当
nFlag等于reposDefault时，RepositionBars函数将在最后把id为nIDLeftOver的子窗口的大小和位置调整到被其他
子窗口切剩的可用区域内，使这个子窗口正好完全覆盖最后的可用区域。而当nFlag等于reposExtra时，RepositionBars在调整id
为nIDLeftOver的子窗口的大小和位置前，还要用
lpRectParam来对最后剩下的可用区域做修正。假设lpRect指向的是最后的可用区域，那么这个修正是这样进行的：
6 F; Q0 _' s5 \9 i9 Z# b0 U
7 o, a. o8 ?, D: D9 ^5 s
" D+ B3 d. F5 ]lpRect->top+=lpRectParam->top;
. M. k9 r+ f0 E$ H3 a9 Slprect->left+=lpRectParam->left;
, ~2 w4 v' p, B" m# |2 [lpRect->right-=lpRectParam->right;
$ K) G$ y+ L, F9 ], B& AlpRect->bottom-=lpRectParam->bottom;
) p. G4 n2 ^) R8 P" K D9 y" ]2 h M, g8 f
通过这样的修正，可以使最后剩下的可用区域不被id为nIDLeftOver的子窗口占满，而是空出一些地方来留作他用。
1 ]# d# r1 ?+ J" E: u, O/ ?- u: {1 S- E! e
（5）bStretch
* H. f" B) p5 e) \
/ R% v" @/ V0 e: q0 S1 ~这个参数上面已经提到一点
它的作用。它主要是提供给各个响应WM_SIZEPARENT消息的子窗口用的，子窗口例如工具栏，状态条等在决定自己将从父窗口客户区的可用空间里划走
多少时，这个参数也是个判断的依据。详细可以参阅工具栏和状态条响应WM_SIZEPARENT的函数OnSizeParent()。
! t' @% ]& b3 b" a
3 D: W2 \4 r/ M6 k) y C3 M0 f0 m' z2。消息WM_SIZEPARENT
0 _. |) B9 o+ g7 q) L! g0 i$ Y; A4 x
% R8 B( X& `/ n这是个mfc自定义的消息。在msdn里的TN024这篇技术文章里有关于这个消息的说明。
- o/ X2 ?$ D- j- ~, g7 {
5 V4 @" D% X4 |2 I* z该消息的两个参数中wParam不用，lParam是指向一个AFX_SIZEPARENTPARAMS结构变量的指针，这个结构变量是在RepositionBars函数里定义的：
9 N" V& ^3 e) j/ T0 o$ Z
+ I( f, t6 y* h1 j7 G* ?AFX_SIZEPARENTPARAMS layout;
|$ `/ m4 K' ~
+ E, k5 J* R8 I, KAFX_SIZEPARENTPARAMS结构定义如下：
$ I0 @8 ~4 A2 p" H% n6 l4 [; g
, C! k( J. M( h7 P9 }% y
struct AFX_SIZEPARENTPARAMS
* I6 ?: c) M! a1 ]{
% E9 d# h0 J" n+ ~6 ?HDWP hDWP;
; [- ?0 i$ ]% ^ p& y6 L: z2 T* WRECT rect;
3 d# s# C: p" v1 m# R7 z' r, j
SIZE sizeTotal;
, W- _8 _5 R4 E. @
BOOL bStretch;
" I; g) p0 S% y: P E- k
};
* f" e- e- J* a B5 C9 G+ p% P. u这个结
构变量的成员是在RepositionBars函数里填写的：它的bStretch成员就是RepositionBars的参数bStretch，它的
sizeTotal成员的两个成员cx和cy都被设置为零，它的rect成员就是从RepositionBars的参数lpRectClient里拷贝过
来的，就是父窗口客户区的初始可用区域嘛。每个响应这个消息的子窗口都必须修改rect成员的值，以便切去自己所占据的部分。
) B* I5 x) v# j: d0 y% o2 C
成员hDWP是什么？这得知道三个api函数：BebinDeferWindowPos()，DeferWindowPos()和
EndDeferWindowPos()。这三个api函数是用来成批设置窗口的位置和尺寸的。BebinDeferWindowPos()先通知
windows分配一个将用来存贮窗口的位置和尺寸信息的结构，它不是返回这个结构的指针，而是返回代表这个结构的句柄，句柄的类型是HDWP。然后每个
需要重新设置位置和尺寸的窗口都要调用DeferWindowPos()函数(该函数需要那个HDWP
类型的句柄为参数)，以便往那个结构里填写各自的窗口位置和大小信息。最后，在某个合适的时候调用
EndDeferWindowPos()，windows就会根据那个结构里的信息把有关的窗口的位置和大小一次性设置好。比起针对每个窗口分别用
SetWindowPos()等函数逐个设置来说，这种方法速度快。
" s8 H9 U- T( f, B8 j0 x: ~
' Q4 S" s4 v. M1 J
好了，在RepositionBars函数里正是调用了BebinDeferWindowPos()，获得一个HDWP类型的句柄，这个句柄就被填写到了
上面那个结构变量
layout的成员hDWP里。然后RepositionBars函数给每个符合条件的子窗口发送WM_SIZEPARENT消息。在每个响应
WM_SIZEPARENT消息的子窗口里，要调用DeferWindowPos()来设置位置和尺寸信息。当所有的子窗口都响应完毕
WM_SIZEPARENT消息后，RepositionBars函数再调用
EndDeferWindowPos()函数，这一来，除了那个id为nIDLeftOver的子窗口外，所有的子窗口都一次性排好了位置了。
7 }. |" a" v3 J& Q" Y9 ?
, a; z' ~ [4 c" ~2 e: q+ k至于该结构的
sizeTotal成员的意义，它累计每个子窗口所占据掉的可用区域的长宽尺寸和。每个子窗口在响应WM_SIZEPARENT消息时一般都要把自己所占
据的区域的高和宽分别累加到sizeTotal结构的cy和cx成员里。这有什么意义呢？当每个子窗口所占据的区域都是挨在一起的时候，这个
sizeTotal结构就有意义了，主框架窗口可以使nFlag等于reposQuery，使bStretch等于FALSE来调用
RepositionBars函数，RepositionBars函数会把
sizeTotal结构的两个成员值拷贝到lpRectParam参数里返回给主框架类(前面也提到过)，这样主框架类就知道它的客户区内的子窗口占去了
客户区内多大的一块空间。如果你的主框架窗口没有利用这个信息，那么响应WM_SIZEPARENT消息的子窗口就可以不理睬sizeTotal成
员。
6 v- F& L2 Q3 L6 K8 _
8 Z2 }8 R+ X2 W% V/ `/ WID的分配
5 A! R7 X8 k( g
. M! A/ J0 f0 A8 Z5 w可以看到，每个子窗口都有个id，同一个父窗口的子窗口的id不能重复。mfc的一些现成的控件子窗口都有预定义的id：
0 J) ~9 y) W. S& C- Y6 f
1 d: s- T$ n% k+ ~) {7 c& `
id名 id值 意义
2 Q- b7 O( y0 u) p* u" Z- Y3 X; o) R$ _
AFX_IDW_TOOLBAR 0xE800 // 主窗口的工具栏的id
8 i4 D5 I5 d+ t4 C' K3 v
AFX_IDW_STATUS_BAR 0xE801 // 状态栏的id
! ^6 s% U* }# U4 D
AFX_IDW_PREVIEW_BAR 0xE802 // PrintPreview Dialog Bar
4 f M! K' X; m% g; S* }7 ^* nAFX_IDW_RESIZE_BAR 0xE803 // OLE in-place resize bar
* P; c) d0 W9 B- R1 e
AFX_IDW_REBAR 0xE804 // COMCTL32 "rebar" Bar
9 f2 w U& A4 E$ B0 m( O, v: y
AFX_IDW_DIALOGBAR 0xE805 // CDialogBar
4 c# Y' C; t) W" e0 ~& z. u
- W! o1 q7 j1 @0 D' s8 M! y6 ^) ?还有象单文档程序的视图窗口，多文档程序的那个MDIClient窗口，分隔条窗口，他们的id值介于下面两个id值之间：
7 j9 Q8 c' ?8 ^' P
AFX_IDW_PANE_FIRST 0xE900 //
$ O; D [5 z$ i# p- c& I) ` ~
AFX_IDW_PANE_LAST 0xE9FF
. n+ u2 Z. p0 c- _6 p: E
) H& G3 h( m% Q' t/ E你要给你自己的子窗口分配id的话，别和上面的重复了。一般如果用IDE的菜单view/resource symbols项来加入自己的id的话，是不会重复的。有关id，还可以看看msdn里的TN020文章，那是专讲id的。
( ^# j2 O; N# b% h7 k
! @ l y& g [; }! ~$ |实例分析
+ y) k, b# B! ?1 w# L% o4 o5 ^% F. r! U, B. A' U- b4 t
1。CFrameWnd类是如何调用RepositionBars函数的
1 ~, U/ [+ Q5 _
* R% M4 Y+ _, z1 |$ b7 M前面介绍了RepositionBars的各个参数和意义，现在看看CFrameWnd类是如何调用这个函数的，从中可以学习RepositionBars函数的使用方法。
, m5 _0 g f, J
9 @! W% b i/ e+ {$ [CFrameWnd类及其派生类
生成的窗口的客户区内可以有工具栏，状态条和视图窗口等子窗口。当父窗口的尺寸发生变化时，这些子窗口的各自的位置和大小比例关系保持不变，这就需要父窗
口一旦在它自己的尺寸发生变化时就调用RepositionBars函数。CFrameWnd类是集中在函数
RecalcLayout里调用RepositionBars函数的。该类保证了在窗口尺寸发生变化时函数RecalcLayout都被调用，从而
RepositionBars函数也能被及时调用，确保了各个子窗口都能及时调整自己的位置和大小。
6 [$ S# P _( l- V, R
2 i! O1 r! e1 H& s& B) S# ?
RecalcLayout是个虚函数。该函数的功能就是在主框架的客户区内提供一个初始的可用区域，并把这个区域放在一个CRect类型的变量里。该函数大致是这样的：
1 x& a& m6 b4 M3 P; {8 `. @2 }& |
- h Q: l7 U" Q& e J# [5 | s
void CFrameWnd::RecalcLayout(BOOL bNotify)
5 s+ w2 P' _! x{
! `# [- {! c* v! M h
if (m_bInRecalcLayout)
6 s' j- Y& x2 q+ h) g
return;//这大概是在防止该函数重入
/ `. [+ f4 V+ O4 R6 X: ^9 `
m_bInRecalcLayout = TRUE;
) n& ^1 G& I$ N* i0 A f6 j5 B+ h....
6 x2 @) ~) z U....
7 ^1 h2 |. ~8 z( i. S+ U' P" G1 t# m....
" O* y9 O% m1 O! q( e5 g: m& m8 h
....
1 `1 P. ~- q9 Y' k+ |+ vif (GetStyle() & FWS_SNAPTOBARS)
; y' d. U; _2 O; z- a
{
1 Y! U- B0 F& w5 v5 G- aCRect rect(0, 0, 32767, 32767);
* d' P% j9 P6 e# m2 v( }
RepositionBars(0, 0xffff, AFX_IDW_PANE_FIRST, reposQuery,
0 `1 C) t: s! ~, c% {&rect, &rect, FALSE);
. z/ I- O$ d4 J( W r5 F
RepositionBars(0, 0xffff, AFX_IDW_PANE_FIRST, reposExtra,
+ N1 U7 f) x: k: P! W0 [) ~/ |&m_rectBorder, &rect, TRUE);
: k5 a% _0 y' }) @CalcWindowRect(&rect);
) p9 K9 C1 m! f+ hSetWindowPos(NULL, 0, 0, rect.Width(), rect.Height(),
' U3 Y+ N2 k. C2 v# s8 k3 d$ a6 r% eSWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER);
. F# s$ u$ r5 o6 ~, H}
h* L* t( E, X8 m' @; L
else
5 W0 `2 H; R/ P! r# ^8 l
RepositionBars(0, 0xffff, AFX_IDW_PANE_FIRST, reposExtra, &m_rectBorder);
& ~1 Y2 j. S9 }8 a) }, ?
m_bInRecalcLayout = FALSE;
3 k( D' F/ f6 O/ j} 可以看出，mfc认为这个函数是不能重入的。在编制自己的RecalcLayout()函数时也得用同样的方法来防止重入。
' r1 Q3 y. S/ u& W9 e( g* h7 f2 c9 d后面的if语句检查框架窗口是否具有风格FWS_SNAPTOBARS，这个风格用在什么时候呢？我是这样认为的：通常都是在主框架窗口的尺寸改变
! ?; |5 x I/ {9 \* r
时，子窗口在响应WM_SIZEPARENT消息时调整自己的尺寸以便跟上框架窗口的尺寸变化。有这样的情况：父窗口的客户区内的子窗口的数目是动态变
4 u) s+ c C% y& L' Q! I化的，而且这些子窗口互相不能重叠，他们的尺寸由于某种原因不好改变。那么当子窗口的数目发生增减时，如不调整父窗口自己的尺寸，就会导
: M3 ^5 M0 A) H- m* a致客户区留下空白或新增加的子窗口没有多余空间安排。FWS_SNAPTOBARS风格就是用在这种情况下，使父窗口能调整自己的大小以便容纳子窗口。
9 L/ L; K R) r- u- h看这个分支里的语句，似乎是这样的。
0 H. ?1 ~( M/ P" x# |; J
一般都不会有FWS_SNAPTOBARS风格的，所以一般是执行else分支。在这个分支里简单地调用RepositionBars去重排所有的子窗口，它的参数
8 i& |7 J7 R8 Q
lpRectClient 使用默认的NULL值，意思就是初始可用区域是父窗口的整个客户区。
# t4 Y- Y) e0 z5 L3 p可以在自己的派生类里编写自己的RecalcLayout函数，以便用自己的方法调用RepositionBars函数。要注意的是在CFrameWnd类的窗口刚被创建
: [) E! t @* q# N; o; b时RecalcLayout函数也被调用，此时可能某些用户自己加的子窗口还未被创建出来，所以在这个函数内如果要引用某个用户自己加的子窗口的句柄
8 _& j7 \( }! g1 O. I) R" [的话必须先用::IsWindow()函数判断一下该窗口句柄是否可用。否则的话就会出现非法操作了。
+ I f& N) |5 {2 d d P; {0 g; V8 I6 `- o5 v; }6 n2 T+ Z) L
- u( d4 f: B) S: R/ c# n& y实战演练
/ W( J% ]+ ?9 E k: V3 Q+ v3 `# B) J! A
由于精力有限，只提供一个实战例子：将视图，工具栏和状态栏赶到右边
6 |4 z' X: B% \0 i. O% B我们要生成这样的界面：视图窗口，工具栏和状态条统统在右边，左边是个自己加的窗口。
$ ~( }# W2 q$ T" Y" E* K; M, {第一步：启动AppWizard生成一个单文档程序，全部使用默认设置。
5 F7 k* I1 d5 C8 T
第二步：在CMainFrame类里增加一个成员 CWnd m_mywnd。
) b2 }& y8 G( x5 q4 T+ L% i
第三步：在CMainFrame::OnCreate()函数里增加这几行：
( m0 [( l9 }* k
m_mywnd.CreateEx
6 f5 q0 l7 i9 K7 @/ `5 q) ]
(
. @7 a( q$ K4 c" o
WS_EX_CLIENTEDGE,
( X/ J3 P2 C1 v% m' R* n
AfxRegisterWndClass
; y+ G4 y; m, A- o: c" f
(
" a3 h( c K8 X; J2 p ~: `4 w( LCS_HREDRAW|CS_VREDRAW,
" t3 ]2 l; |0 Q; L7 L1 [5 w:
oadCursor(NULL,IDC_ARROW),
4 T l: U5 k1 u0 t7 k::CreateSolidBrush(RGB(190,190,190))
+ h6 K) l- c5 J% K6 u; T1 \# [
),
& l+ M, J8 `0 ?% \. X V2 m. B"",
8 C9 L% _* r0 \: ]0 J8 n8 B( bWS_VISIBLE|WS_CHILD,
; T# p6 _% P# P4 F Q- H5 sCRect(0,0,0,0),
6 _+ @. f; c) V; Nthis,
/ h `; @" Q( e; l" S& dIDC_MYPANE //用IDE的菜单view/resource symbols项加入的id。
' z: x# @3 \( o) @9 O/ u; u
);
8 o, H" g/ A- M- Z+ K; ?
# G" V# ?$ u6 Y. C$ v第四步：启动ClassView，在CMainFrame里加上虚函数RecalcLayout()，函数体这样写：
$ @$ H; {+ b2 }5 o1 [
void CMainFrame::RecalcLayout(BOOL bNotify)
$ C2 b; Y) A% B: @; Q% j. P{
& L( `3 A0 I) @+ {/ D7 x
if (m_bInRecalcLayout)
4 K6 ~# I8 J. O: n: j2 x0 F8 Z, x
return;
( c1 @" F4 M$ ]: f6 zm_bInRecalcLayout = TRUE;
. B; ]0 `+ R3 s( J4 I1 r- l
; p n1 |. C9 h* e$ x k8 G" [
//rect1是新加的窗口将占据的区域
0 r: F6 X8 B F1 B3 G//rect2就是提供给工具栏，状态条和视图窗口的初始可用区域。
# s4 E( [; u8 U" gCRect rect1,rect2;
; y2 Y' B6 \; f3 n/ g7 i7 q) f
GetClientRect(&rect1);
- ?6 V$ o* W' @" |% x+ a
rect1.right=rect1.right/3;
, _' w/ K8 {) V* `& D" Y6 b4 g
GetClientRect(&rect2);
' E; m; ?6 P% \) k5 P# T/ frect2.left=rect2.right/3;
" R t( c' A% _
6 g! @' W5 [7 ?# J# |2 m u
if(::IsWindow(m_mywnd.m_hWnd)) //这句是不能少的
* D; F4 F; O7 X. d9 S8 Im_mywnd.MoveWindow(&rect1);
2 r& [, s A8 B: V
RepositionBars(0, 0xffff, AFX_IDW_PANE_FIRST, reposExtra, CRect(0,0,0,0),&rect2);
; Q( }6 O: K! V" T6 A2 e$ K3 Vm_bInRecalcLayout = FALSE;
- x2 G& |' Q7 Z7 j1 y
}
$ d/ ?; a# w6 W7 ?5 F% ^- S5 H# W
$ G6 G" b; |. I1 W* H第五步：用IDE的菜单view/resource symbols项加入一个id：IDC_MYPANE。
0 j8 F% E3 w, P7 f1 f }
第六步：编译并运行程序。
1 U. c! _# F' `1 e1 X1 G/ o7 L
# N m Y5 y) _, J+ B! x6 [好了，在主框架窗口的左边多了一个灰色的窗口，它占主窗口客户区的三分之一。工具栏，状态条和视图都被赶到右边三分之二的地方去了。
