如何实现对话框的窗体分割？？？大家进来up一下也有分……

[962veiri]

现在我要完成一个类似windows操作系统自带的搜索模块，就是一个对话框，左边是条件输入，右边是结果显示，中间是分割条，而且这个程序一定要对话框来实现，不知道大家有没有类似的东西？？？？或者是跟我讲解一下实现方法也可以。在线等候，up也给分，谢谢！

[blue_flash]

IMPLEMENT_DYNCREATE(CSplitterCtrl, CWnd)

CSplitterCtrl::CSplitterCtrl() :
m_bDraging( FALSE )
{
// register the window class
WNDCLASS wndclass;
HINSTANCE hInst = AfxGetInstanceHandle();
CTreeListResource TreeListResource;

if(!(::GetClassInfo(hInst, SPLITTERCTRL_CLASSNAME, &wndclass)))
{
wndclass.style = CS_HREDRAW | CS_VREDRAW ; //CS_SAVEBITS ;
wndclass.lpfnWndProc = ::DefWindowProc;
wndclass.cbClsExtra = wndclass.cbWndExtra = 0;
wndclass.hInstance = hInst;
wndclass.hIcon = NULL;
wndclass.hCursor = AfxGetApp()->LoadStandardCursor( IDC_ARROW);
wndclass.hbrBackground = (HBRUSH)(COLOR_3DFACE + 1);
wndclass.lpszMenuName = NULL;
wndclass.lpszClassName = SPLITTERCTRL_CLASSNAME;
if (!AfxRegisterClass(&wndclass))
AfxThrowResourceException();
}

// default color
m_cr3DFace = GetSysColor( COLOR_3DFACE );
m_cr3DLight = GetSysColor( COLOR_3DHILIGHT );
m_cr3DShadow = GetSysColor( COLOR_3DSHADOW );

// defautl cursor
m_hVert = AfxGetApp()->LoadCursor( IDC_CURSOR_VERT );
m_hHorz = AfxGetApp()->LoadCursor( IDC_CURSOR_HORZ );
m_hCross = AfxGetApp()->LoadCursor( IDC_CURSOR_CROSS );
//m_hArrow =
}

CSplitterCtrl::~CSplitterCtrl()
{
for( int iCol=0; iCol<m_arCols.GetSize(); iCol++ )
{
CPaneColInfo* pColInfo;
pColInfo = (CPaneColInfo*)m_arCols[iCol];
delete pColInfo;
}

for( int iRow=0; iRow<m_arRows.GetSize(); iRow++ )
{
CPaneRowInfo* pRowInfo;
pRowInfo = (CPaneRowInfo*)m_arRows[iRow];
delete pRowInfo;
}

for( int iPane=0; iPane<m_arPanes.GetSize(); iPane++ )
{
CPaneInfo* pPaneInfo;
pPaneInfo = (CPaneInfo*)m_arPanes[iPane];
delete pPaneInfo;
}

m_arCols.RemoveAll();
m_arRows.RemoveAll();
m_arPanes.RemoveAll();

m_arColGaps.RemoveAll();
m_arRowGaps.RemoveAll();

// free cursors
if( m_hVert != NULL )
DestroyCursor( m_hVert );

if( m_hHorz != NULL )
DestroyCursor( m_hHorz );

if( m_hCross != NULL )
DestroyCursor( m_hCross );
}

BEGIN_MESSAGE_MAP(CSplitterCtrl, CWnd)
//{{AFX_MSG_MAP(CSplitterCtrl)
ON_WM_ERASEBKGND()
ON_WM_PAINT()
ON_WM_SIZE()
ON_WM_MOUSEMOVE()
ON_WM_LBUTTONDOWN()
ON_WM_LBUTTONUP()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CSplitterCtrl message handlers
BOOL CSplitterCtrl::Create(CRect rcWindow, CWnd* pParent, int nCols, int nRows )
{
ASSERT_VALID( pParent );
ASSERT( nCols > 0 && nRows > 0 );

for( int iCol=0; iCol<nCols; iCol++ )
{
CPaneColInfo* pColInfo;
pColInfo = new CPaneColInfo;
pColInfo->m_nWidth = 200;
m_arCols.Add( pColInfo );

m_arColGaps.Add( 4 );
}

for( int iRow=0; iRow<nRows; iRow++ )
{
CPaneRowInfo* pRowInfo;
pRowInfo = new CPaneRowInfo;
pRowInfo->m_nHeight = 200;
m_arRows.Add( pRowInfo );

m_arRowGaps.Add( 4 );
}

for( iRow=0; iRow<nRows; iRow++ )
{
for( iCol=0; iCol<nCols; iCol++ )
{
CPaneInfo* pPaneInfo;
pPaneInfo = new CPaneInfo;
m_arPanes.Add( pPaneInfo );
}
}

DWORD dwStyle = WS_CHILD | WS_VISIBLE;
DWORD dwExStyle = 0; //WS_EX_TRANSPARENT;

if( !CreateEx( dwExStyle, SPLITTERCTRL_CLASSNAME, NULL, dwStyle,
rcWindow.left, rcWindow.top, rcWindow.Width(), rcWindow.Height(), pParent->GetSafeHwnd(), NULL, NULL ) )
return FALSE;

Layout();

CRect rcSplitter;
GetWindowRect( rcSplitter );
pParent->ScreenToClient( rcSplitter );

// SetWindowPos( &wndBottom, rcSplitter.left, rcSplitter.top, 0, 0, SWP_NOOWNERZORDER | SWP_SHOWWINDOW | SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE );

return TRUE;
}

BOOL CSplitterCtrl::SetPane( CWnd* pWnd, int iCol, int iRow )
{
ASSERT( pWnd != NULL );
ASSERT( 0 <= iCol && iCol < m_arCols.GetSize() );
ASSERT( 0 <= iRow && iRow < m_arRows.GetSize() );

int iPane = iRow*m_arCols.GetSize() + iCol;

CPaneInfo* pPaneInfo = (CPaneInfo*)m_arPanes[iPane];
pPaneInfo->pWnd = pWnd;

pPaneInfo->pWnd->SetWindowPos( &wndTop, 0, 0, 0, 0, SWP_NOOWNERZORDER | SWP_SHOWWINDOW | SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE );

ResizePanes();

return TRUE;
}

[blue_flash]

BOOL CSplitterCtrl::SetCol( int iCol, int nWidth, int nMin, int nMax )
{
CPaneColInfo* pColInfo;
pColInfo = (CPaneColInfo*)m_arCols[iCol];

if( nMax == 0 )
{
ASSERT( nMin <= nWidth );
pColInfo->m_nWidth = nWidth;
pColInfo->m_nMin = nMin;
pColInfo->m_nMax = nMax;
}
else
{
ASSERT( nMin <= nWidth && nWidth <= nMax );
pColInfo->m_nWidth = nWidth;
pColInfo->m_nMin = nMin;
pColInfo->m_nMax = nMax;
}

Layout();

return TRUE;
}

BOOL CSplitterCtrl::SetRow( int iRow, int nHeight, int nMin, int nMax )
{
CPaneRowInfo* pRowInfo;
pRowInfo = (CPaneRowInfo*)m_arRows[iRow];

if( nMax == 0 )
{
ASSERT( nMin <= nHeight );
pRowInfo->m_nHeight = nHeight;
pRowInfo->m_nMin = nMin;
pRowInfo->m_nMax = nMax;
}
else
{
ASSERT( nMin <= nHeight && nHeight <= nMax );
pRowInfo->m_nHeight = nHeight;
pRowInfo->m_nMin = nMin;
pRowInfo->m_nMax = nMax;
}

Layout();

return TRUE;
}

BOOL CSplitterCtrl::OnEraseBkgnd(CDC* pDC)
{
return TRUE;
}

void CSplitterCtrl::OnPaint()
{
CPaintDC dc(this);

CRect rcClient;
GetClientRect( rcClient );

CRect rcPanes;
rcPanes.SetRect( 0, 0, GetWidth(), GetHeight() );
rcPanes.OffsetRect( rcClient.left, rcClient.top );

if( rcPanes.Width() < rcClient.Width() || rcPanes.Height() < rcClient.Height() )
{
dc.ExcludeClipRect( rcPanes );
dc.FillSolidRect( rcClient, m_cr3DFace );
::ExtSelectClipRgn( dc.m_hDC, 0, RGN_COPY );
}

DrawSplitter( &dc );
}

BOOL CSplitterCtrl::DrawSplitter( CDC* pDC )
{
CPaneColInfo* pColInfo;
CPaneRowInfo* pRowInfo;

int nCX, nCY;

nCY = 0;
for( int iRow=0; iRow<m_arRows.GetSize(); iRow++ )
{
pRowInfo = ( CPaneRowInfo* )m_arRows[iRow];

nCX = 0;
for( int iCol=0; iCol<m_arCols.GetSize(); iCol++ )
{
pColInfo = ( CPaneColInfo* )m_arCols[iCol];

// draw pane[iCol][iRow]
DrawSplitterPane( pDC, nCX, nCY, iCol, iRow );

// draw vert line of splitter
DrawSplitterVert( pDC, nCX, nCY, iCol, iRow );

// draw horz line of splitter
DrawSplitterHorz( pDC, nCX, nCY, iCol, iRow );

// draw cross of splitter
DrawSplitterCross( pDC, nCX, nCY, iCol, iRow );

nCX += pColInfo->m_nWidth;
nCX += m_arColGaps[iCol];
}

nCY += pRowInfo->m_nHeight;
nCY += m_arRowGaps[iRow];
}

return TRUE;
}

BOOL CSplitterCtrl::DrawSplitterPane( CDC* pDC, int nCX, int nCY, int iCol, int iRow )
{
// draw pane area
CPaneColInfo* pColInfo = NULL;
CPaneRowInfo* pRowInfo = NULL;
CPaneInfo* pPaneInfo = NULL;

int iPane = iRow*m_arCols.GetSize()+iCol;

pColInfo = ( CPaneColInfo* )m_arCols[iCol];
pRowInfo = ( CPaneRowInfo* )m_arRows[iRow];
pPaneInfo = ( CPaneInfo*)m_arPanes[iPane];


CRect rcPane;
rcPane.SetRect( 0, 0, pColInfo->m_nWidth, pRowInfo->m_nHeight );
rcPane.OffsetRect( nCX, nCY );

CWnd* pWnd = pPaneInfo->pWnd;
if( pWnd != NULL && IsWindow( pWnd->GetSafeHwnd() ) )
{
// CRect rcWnd;
// pWnd->GetWindowRect( rcWnd );
// ScreenToClient( rcWnd );

// pDC->ExcludeClipRect( rcWnd );
// pDC->FillSolidRect( rcPane, m_cr3DFace );
// ::ExtSelectClipRgn( pDC->m_hDC, 0, RGN_COPY );
}
else
{
pDC->FillSolidRect( rcPane, m_cr3DFace );
}

return TRUE;
}

BOOL CSplitterCtrl::DrawSplitterVert( CDC* pDC, int nCX, int nCY, int iCol, int iRow )
{
// draw vert line of splitter
if( iCol<m_arCols.GetUpperBound() )
{
CPaneColInfo* pColInfo = NULL;
CPaneRowInfo* pRowInfo = NULL;

pColInfo = ( CPaneColInfo* )m_arCols[iCol];
pRowInfo = ( CPaneRowInfo* )m_arRows[iRow];

CRect rcVert;
rcVert.SetRect( 0, 0, m_arColGaps[iCol], pRowInfo->m_nHeight );
rcVert.OffsetRect( nCX, nCY );
rcVert.OffsetRect( pColInfo->m_nWidth, 0 );
rcVert.InflateRect( 0, 1, 0, 1 );

pDC->FillSolidRect( rcVert, m_cr3DFace );
pDC->DrawEdge( rcVert, BDR_RAISEDINNER, BF_LEFT | BF_RIGHT );

// rcVert.DeflateRect( 2, 0, 2, 0 );
// pDC->DrawEdge( rcVert, BDR_RAISEDINNER, BF_LEFT | BF_RIGHT );
}

return TRUE;
}

BOOL CSplitterCtrl::DrawSplitterHorz( CDC* pDC, int nCX, int nCY, int iCol, int iRow )
{
// draw horz line of splitter
if( iRow<m_arRows.GetUpperBound() )
{
CPaneColInfo* pColInfo = NULL;
CPaneRowInfo* pRowInfo = NULL;

pColInfo = ( CPaneColInfo* )m_arCols[iCol];
pRowInfo = ( CPaneRowInfo* )m_arRows[iRow];

CRect rcHorz;
rcHorz.SetRect( 0, 0, pColInfo->m_nWidth, m_arRowGaps[iRow] );
rcHorz.OffsetRect( nCX, nCY );
rcHorz.OffsetRect( 0, pRowInfo->m_nHeight );
rcHorz.InflateRect( 1, 0, 1, 0 );

pDC->FillSolidRect( rcHorz, m_cr3DFace );
pDC->DrawEdge( rcHorz, BDR_RAISEDINNER, BF_TOP | BF_BOTTOM );

// rcHorz.DeflateRect( 0, 2, 0, 2 );
// pDC->DrawEdge( rcHorz, BDR_RAISEDINNER, BF_TOP | BF_BOTTOM );
}

return TRUE;
}

[962veiri]

啊？确实太长了，看了头晕；）
不过还是要感谢blue_flash(蓝色闪电) ，分数肯定会给你的，不过你的代码
没有注释，很难看董呀

[blue_flash]

BOOL CSplitterCtrl::SetHeightAbove( int nAbove, int iSplit )
{
int iRow;
int nDelta;

nDelta = nAbove;
for( iRow =iSplit; iRow >= 0; iRow-- )
{
CPaneRowInfo* pRowInfo;
pRowInfo = (CPaneRowInfo*)m_arRows[iRow];

if( pRowInfo->m_nMin < pRowInfo->m_nHeight )
{
int nRowDelta = pRowInfo->m_nHeight - pRowInfo->m_nMin;
if( nRowDelta < nDelta )
{
pRowInfo->m_nHeight -= nRowDelta;
nDelta -= nRowDelta;
}
else
{
pRowInfo->m_nHeight -= nDelta;
nDelta -= nDelta;
}
}

if( nDelta <= 0 )
{
break;
}
}

nDelta = nAbove;
for( iRow = iSplit+1; iRow < m_arRows.GetSize(); iRow++ )
{
CPaneRowInfo* pRowInfo;
pRowInfo = (CPaneRowInfo*)m_arRows[iRow];

if( pRowInfo->m_nMax == 0 )
{
pRowInfo->m_nHeight += nDelta;
nDelta -= nDelta;
}

if( pRowInfo->m_nMax > pRowInfo->m_nHeight )
{
int nRowDelta = pRowInfo->m_nMax - pRowInfo->m_nHeight;
if( nRowDelta < nDelta )
{
pRowInfo->m_nHeight += nRowDelta;
nDelta -= nRowDelta;
}
else
{
pRowInfo->m_nHeight += nDelta;
nDelta -= nDelta;
}
}

if( nDelta <= 0 )
{
break;
}
}

return TRUE;
}

BOOL CSplitterCtrl::SetHeightBelow( int nBelow, int iSplit )
{
int iRow;
int nDelta;

nDelta = nBelow;
for( iRow =iSplit; iRow >= 0; iRow-- )
{
CPaneRowInfo* pRowInfo;
pRowInfo = (CPaneRowInfo*)m_arRows[iRow];

if( pRowInfo->m_nMax == 0 )
{
pRowInfo->m_nHeight += nDelta;
nDelta -= nDelta;
}

if( pRowInfo->m_nMax > pRowInfo->m_nHeight )
{
int nRowDelta = pRowInfo->m_nMax - pRowInfo->m_nHeight;
if( nRowDelta < nDelta )
{
pRowInfo->m_nHeight += nRowDelta;
nDelta -= nRowDelta;
}
else
{
pRowInfo->m_nHeight += nDelta;
nDelta -= nDelta;
}
}

if( nDelta <= 0 )
{
break;
}
}

nDelta = nBelow;
for( iRow = iSplit+1; iRow < m_arRows.GetSize(); iRow++ )
{
CPaneRowInfo* pRowInfo;
pRowInfo = (CPaneRowInfo*)m_arRows[iRow];

if( pRowInfo->m_nMin < pRowInfo->m_nHeight )
{
int nRowDelta = pRowInfo->m_nHeight - pRowInfo->m_nMin;
if( nRowDelta < nDelta )
{
pRowInfo->m_nHeight -= nRowDelta;
nDelta -= nRowDelta;
}
else
{
pRowInfo->m_nHeight -= nDelta;
nDelta -= nDelta;
}
}

if( nDelta <= 0 )
{
break;
}
}

return TRUE;
}

BOOL CSplitterCtrl::Layout()
{
CRect rcClient;
GetClientRect( rcClient );

SetWidth( rcClient.Width() );
SetHeight( rcClient.Height() );

Invalidate();
UpdateWindow();

return TRUE;

}

是呀，本来也是写给自己的。

[blue_flash]

BOOL CSplitterCtrl::Layout( CPoint pt )
{
ASSERT( m_bDraging );
BOOL bUpdate = FALSE;

if( m_bDragVert && pt.x != m_ptBegin.x )
{
int nDelta = 0;
int nMax, nLeft, nRight;

if( pt.x < m_ptBegin.x )
{
nMax = GetMaxWidthRight( m_iCol );
nLeft = GetWidthLeft( m_iCol ) - GetMinWidthLeft( m_iCol );
nRight = GetMaxWidthRight( m_iCol ) - GetWidthRight( m_iCol );

if( nMax == 0 )
nDelta = nLeft;
else
nDelta = min( nLeft, nRight );

nDelta = min( nDelta, m_ptBegin.x - pt.x );

if( nDelta > 0 )
{
LayoutVertLeft( nDelta );
m_ptBegin.x -= nDelta;
bUpdate = TRUE;
}
}
else
{
nMax = GetMaxWidthLeft( m_iCol );
nLeft = GetMaxWidthLeft( m_iCol ) - GetWidthLeft( m_iCol );
nRight = GetWidthRight( m_iCol ) - GetMinWidthRight( m_iCol );

if( nMax == 0 )
nDelta = nRight;
else
nDelta = min( nLeft, nRight );

nDelta = min( nDelta, pt.x - m_ptBegin.x );

if( nDelta > 0 )
{
LayoutVertRight( nDelta );
m_ptBegin.x += nDelta;
bUpdate = TRUE;
}
}

}

if( m_bDragHorz && pt.y != m_ptBegin.y )
{
int nDelta = 0;
int nMax, nAbove, nBelow;

if( pt.y < m_ptBegin.y )
{
nMax = GetMaxHeightBelow( m_iRow );
nAbove = GetHeightAbove( m_iRow ) - GetMinHeightAbove( m_iRow );
nBelow = GetMaxHeightBelow( m_iRow ) - GetHeightBelow( m_iRow );

if( nMax == 0 )
nDelta = nAbove;
else
nDelta = min( nAbove, nBelow );

nDelta = min( nDelta, m_ptBegin.y - pt.y );

if( nDelta > 0 )
{
LayoutHorzAbove( nDelta );
m_ptBegin.y -= nDelta;
bUpdate = TRUE;
}
}
else
{
nMax = GetMaxHeightAbove( m_iRow );
nAbove = GetMaxHeightAbove( m_iRow ) - GetHeightAbove( m_iRow );
nBelow = GetHeightBelow( m_iRow ) - GetMinHeightBelow( m_iRow );

if( nMax == 0 )
nDelta = nBelow;
else
nDelta = min( nAbove, nBelow );

nDelta = min( nDelta, pt.y - m_ptBegin.y );

if( nDelta > 0 )
{
LayoutHorzBelow( nDelta );
m_ptBegin.y += nDelta;
bUpdate = TRUE;
}
}
}

if( bUpdate )
{
ResizePanes();
}

return TRUE;
}

BOOL CSplitterCtrl::ResizePanes()
{
CPaneInfo* pPaneInfo;
CPaneColInfo* pColInfo;
CPaneRowInfo* pRowInfo;

int CX = 0;
int CY = 0;

for( int iRow=0; iRow<m_arRows.GetSize(); iRow++ )
{
pRowInfo = (CPaneRowInfo*)m_arRows[iRow];

CX = 0;
for( int iCol=0; iCol<m_arCols.GetSize(); iCol++ )
{
pColInfo = (CPaneColInfo*)m_arCols[iCol];
int iPane = iRow*m_arCols.GetSize()+iCol;

pPaneInfo = (CPaneInfo*)m_arPanes[iPane];

CRect rcPane;
rcPane.SetRect( 0, 0, pColInfo->m_nWidth, pRowInfo->m_nHeight );
rcPane.OffsetRect( CX, CY );
ClientToScreen( rcPane );
GetParent()->ScreenToClient( rcPane );

CWnd* pWnd = pPaneInfo->pWnd;
if( pWnd != NULL && IsWindow( pWnd->GetSafeHwnd() ) )
{
pWnd->Invalidate();
pWnd->MoveWindow( rcPane );
}

CX += pColInfo->m_nWidth;
CX += m_arColGaps[iCol];
}

CY += pRowInfo->m_nHeight;
CY += m_arRowGaps[iRow];
}

CWnd* pWnd = NULL;
pWnd = GetParent();
while( pWnd->IsKindOf( RUNTIME_CLASS(CSplitterCtrl) ) )
{
pWnd = pWnd->GetParent();
}

ASSERT( pWnd != NULL );

CRect rcWindow;
pWnd->GetWindowRect( &rcWindow );
pWnd->SendMessage( WM_SIZE, 0, MAKEWPARAM( rcWindow.Width(), rcWindow.Height() ) );

return TRUE;
}

BOOL CSplitterCtrl::LayoutVertLeft( int nLeft )
{
SetWidthLeft( nLeft, m_iCol );

Invalidate();
UpdateWindow();

return TRUE;
}

[blue_flash]

BOOL CSplitterCtrl::LayoutVertRight( int nRight )
{
SetWidthRight( nRight, m_iCol );

Invalidate();
UpdateWindow();

return TRUE;
}

BOOL CSplitterCtrl::LayoutHorzAbove( int nAbove )
{
SetHeightAbove( nAbove, m_iRow );

Invalidate();
UpdateWindow();

return TRUE;
}

BOOL CSplitterCtrl::LayoutHorzBelow( int nBelow )
{
SetHeightBelow( nBelow, m_iRow );

Invalidate();
UpdateWindow();

return TRUE;
}

void CSplitterCtrl::OnSize(UINT nType, int cx, int cy)
{
CWnd::OnSize(nType, cx, cy);

if( nType != SIZE_MINIMIZED )
{
Layout();
ResizePanes();
}
}

void CSplitterCtrl::OnMouseMove(UINT nFlags, CPoint point)
{
int nFlag, nCol, nRow;

if( !m_bDraging )
{
if( HitTest( point, nFlag, nCol, nRow ) )
{
if( (nFlag&SCHT_ONCROSS) == SCHT_ONCROSS )
{
SetCursor( m_hCross );
}
else if( nFlag&SCHT_ONVERTLINE )
{
SetCursor( m_hVert );
}
else if( nFlag&SCHT_ONHORZLINE )
{
SetCursor( m_hHorz );
}
}
}
else
{
Layout( point );
}

CWnd::OnMouseMove(nFlags, point);
}

void CSplitterCtrl::OnLButtonDown(UINT nFlags, CPoint point)
{
int nFlag, nCol, nRow;

if( !m_bDraging )
{
if( HitTest( point, nFlag, nCol, nRow ) )
{
if( (nFlag&SCHT_ONCROSS) == SCHT_ONCROSS )
{
SetCursor( m_hCross );
}
else if( nFlag&SCHT_ONVERTLINE )
{
SetCursor( m_hVert );
}
else if( nFlag&SCHT_ONHORZLINE )
{
SetCursor( m_hHorz );
}

m_bDraging = TRUE;
m_bDragVert = FALSE;
m_bDragHorz = FALSE;

if( nFlag&SCHT_ONVERTLINE )
{
m_bDragVert = TRUE;
m_iCol = nCol;
}

if( nFlag&SCHT_ONHORZLINE )
{
m_bDragHorz = TRUE;
m_iRow = nRow;
}

m_ptBegin = point;

SetCapture();
CRect rcClient;
GetClientRect( rcClient );
ClientToScreen( rcClient );

ClipCursor( rcClient );
}
}
}

void CSplitterCtrl::OnLButtonUp(UINT nFlags, CPoint point)
{
if( m_bDraging )
{
m_bDraging = FALSE;
m_bDragVert = FALSE;
m_bDragHorz = FALSE;

ClipCursor( NULL );

ReleaseCapture();
}

CWnd::OnLButtonUp(nFlags, point);
}

BOOL CSplitterCtrl::HitTest( CPoint pt, int& nFlag, int& nCol, int& nRow )
{
nFlag = 0;
nCol = 0;
nRow = 0;

CRect rcClient;
GetClientRect( rcClient );
if( !rcClient.PtInRect( pt ) )
return FALSE;

int nCX = 0;
int nCY = 0;

int nWidth = GetWidth();
int nHeight = GetHeight();

for( int iCol=0; iCol<m_arCols.GetUpperBound(); iCol++ )
{
CPaneColInfo* pColInfo;
pColInfo = (CPaneColInfo*)m_arCols[iCol];

nCX += pColInfo->m_nWidth;

CRect rcVert;
rcVert.SetRect( 0, 0, m_arColGaps[iCol], nHeight );
rcVert.OffsetRect( rcClient.left, rcClient.top );
rcVert.OffsetRect( nCX, 0 );

if( rcVert.PtInRect( pt ) )
{
nFlag |= SCHT_ONVERTLINE;
nCol = iCol;
break;
}

nCX += m_arColGaps[iCol];
}

for( int iRow=0; iRow<m_arRows.GetUpperBound(); iRow++ )
{
CPaneRowInfo* pRowInfo;
pRowInfo = (CPaneRowInfo*)m_arRows[iRow];

nCY += pRowInfo->m_nHeight;

CRect rcHorz;
rcHorz.SetRect( 0, 0, nWidth, m_arRowGaps[iRow] );
rcHorz.OffsetRect( rcClient.left, rcClient.top );
rcHorz.OffsetRect( 0, nCY );

if( rcHorz.PtInRect( pt ) )
{
nFlag |= SCHT_ONHORZLINE;
nRow = iRow;
break;
}

nCY += m_arRowGaps[iRow];
}

if( !(nFlag&SCHT_ONSPLITTER) )
{
return FALSE;
}

return TRUE;
}

BOOL CSplitterCtrl::PreTranslateMessage(MSG* pMsg)
{
// post message of mouse and key to parent window
CWnd* pWnd;

switch( pMsg->message )
{
case WM_MOUSEMOVE:
if( !m_bDraging )
{
POINTS points = MAKEPOINTS( pMsg->lParam );
POINT pt;
pt.x = points.x;
pt.y = points.y;

pWnd = GetParent();

int nFlag, nCol, nRow;
if( !HitTest( pt, nFlag, nCol, nRow ) )
{
ClientToScreen( &pt );
pWnd->ScreenToClient( &pt );
pMsg->lParam = MAKELONG( pt.x, pt.y );
pWnd->SendMessage( pMsg->message, pMsg->wParam, pMsg->lParam );
return TRUE;
}
}
break;

default:
;
}

return CWnd::PreTranslateMessage(pMsg);
}

-- 完 --

[jaidy]

up

[yheysj]

up!!!

[962veiri]

blue_flash(蓝色闪电) ，看不懂呀 ：（

[962veiri]

高手们，请留下一段实用的代码吧！！！！我要的是把对话框分割成类似于windows自带的搜索程序的样子，OK？？？分数不够可以再加！！！！！！！！！！这么大的一个CSDN呀，怎么没人知道？

[962veiri]

怎么没人帮忙呀？？？？？？？？？？？？？
失望呀……CSDN，原来是菜鸟的地方吗？

[leecyi]

Up.动态设置对话框的区域。SetWindowRgn（）这个函数可能对你有用。

[962veiri]

唉……快受不了了

[fhbkyo]

用CSplitterWnd类
主要成员函数：
CsplitterWnd();//构造CsplitterWnd对象
Create();//为CSplitterWnd对象创建一个动态切分窗口
CreateStatic();//为CSplitterWnd对象创建一个静态切分窗口
CreateView();//在切分窗口中创建一个窗格
GetRowCount();//返回当前窗格行数
SetColumnCount();//返回当前窗格列数
GetRowInfo();//返回指定行信息
SetRowInfo();//设置指定行信息
GetColumnInfo();//返回指定列信息
SetColumnInfo();//设置指定列信息
GetPane();//返回位于指定行和列处的窗格
IsChildPane();//确定窗口是否是此窗口的当前子窗格
IdFromRowCol();//返回位于指定行和列处的窗格ID
IDRecalcLayout();//调整行或列尺寸后调用此函数重新显示该切分窗口
OnDrawSplitter();//绘制切分窗口的图像
OnInvertTracker();//绘制切分窗口的图像，使它具有与框架窗口相同的大
//小和形状
CreateScrollBarCtrl();//创建一个共享的流动条控件
DeleteView();//从切分窗口中删除一个视区
SplitRow();//确定指定框架窗口是否是水平分隔的
SplitColumn();//确定指定框架窗口是否是垂直分隔的
DeleteRow();//从切分窗口中删除一行
DeleteColumn();//从切分窗口中删除一列
GetActivePane();//根据焦点或框架中的视区来确定活动窗格
SetActivePane();//在框架中设置一个活动窗格
CanActiveNext();//检查Next Pane OR Previous Pane命令当前是否有效
ActiveNext();//执行Next Pane OR Previous Pane命令
DoKeyboardSplit();//执行键盘分隔命令，通常是Window Split
DoScroll();//执行分隔窗口的同步滚动
DoScrollBy();//将分隔窗口滚动给定的像素数

[KevinListening]

为什么一定要用对话框？
用FormView分割不行么？即分割窗口后，视图用FormView完成对话框的功能！

[962veiri]

现在是我的AppWirzard里面根本就没有CSplitterWnd这个类来让我派生，怎么办

[962veiri]

FormView???我的模块是以对话框的形式出现在系统中的，怎么用FormView??只要能用类似的方法解决都可以

[fhbkyo]

如有需要找我
QQ:50946510
E_MAIL:[e-mail]

[962veiri]

有人能回答我吗？

[shines77]

参与